{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.10","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Importing Libraries","metadata":{}},{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport tensorflow as tf\nimport wfdb\nimport os                                                                                                         \nimport gc\nimport scipy       \nimport sklearn\nfrom pathlib import Path\nfrom sklearn.utils import shuffle\nfrom sklearn.manifold import TSNE\nimport seaborn as sns\nfrom sklearn import preprocessing\nimport shutil\nimport math\nimport random\nfrom scipy.spatial import distance","metadata":{"execution":{"iopub.status.busy":"2021-06-01T05:22:42.252324Z","iopub.execute_input":"2021-06-01T05:22:42.253031Z","iopub.status.idle":"2021-06-01T05:22:49.674032Z","shell.execute_reply.started":"2021-06-01T05:22:42.252923Z","shell.execute_reply":"2021-06-01T05:22:49.672869Z"},"trusted":true},"execution_count":1,"outputs":[]},{"cell_type":"code","source":"try:\n    tpu = tf.distribute.cluster_resolver.TPUClusterResolver()  # TPU detection\n    print('Running on TPU ', tpu.cluster_spec().as_dict()['worker'])\nexcept ValueError:\n    raise BaseException('ERROR: Not connected to a TPU runtime; please see the previous cell in this notebook for instructions!')\n\ntf.config.experimental_connect_to_cluster(tpu)\ntf.tpu.experimental.initialize_tpu_system(tpu)\ntpu_strategy = tf.distribute.experimental.TPUStrategy(tpu)","metadata":{"execution":{"iopub.status.busy":"2021-06-01T05:22:49.675394Z","iopub.execute_input":"2021-06-01T05:22:49.675692Z","iopub.status.idle":"2021-06-01T05:22:55.517776Z","shell.execute_reply.started":"2021-06-01T05:22:49.675663Z","shell.execute_reply":"2021-06-01T05:22:55.516971Z"},"trusted":true},"execution_count":2,"outputs":[{"name":"stdout","text":"Running on TPU  ['10.0.0.2:8470']\n","output_type":"stream"}]},{"cell_type":"markdown","source":"# Dataset Creation","metadata":{}},{"cell_type":"code","source":"####### Dataset Creation  \n###### Reading Dataset\n\n##### Function to read a record from single dataset\ndef data_read_mit(filepath):\n    \n    \"\"\"\n    Function to read the the inputs from MIT-BIH Dataset\n    INPUTS:- \n    1)filepath: Path to the csv file\n    \n    OUTPUTS:-\n    1)Output_signal: Output 1D array signal \n    \"\"\"\n    return (np.array(pd.read_csv(filepath,index_col=0).iloc[:,[0]]))   \n    \n##### Function to Required Annotations from .txt files\ndef feature_extractor(txt_file_path):\n    \n    \"\"\"\n       Function to extract time series data \n       from a .txt file\n    \"\"\"\n    \n    #### Reading File\n    line_list = []\n\n    with open(txt_file_path, 'r') as reader:\n\n    # Read and print the entire file line by line\n        line = reader.readline()\n        while line != '':  # The EOF char is an empty string\n            #print(line, end='')\n            line_list.append(line)\n            line = reader.readline()\n    \n    #### Taking the Time Step Data\n    line_list = line_list[1:]\n    \n    #### Splitting the Collected Text Strings and Converting them into Floating type values\n    new_list = []\n\n    for item in line_list:\n        for idx,sub_item in enumerate(item.split()):\n            if(idx == 1):\n                new_list.append(int(sub_item))\n                break\n    \n    ### Returning the feature extracted list as numpy array\n    return np.array(new_list)\n\n###### Function to Segment Signals\n##### Constants\nFS = 500\nW_LEN = 256\nW_LEN_1_4 = 256 // 4\nW_LEN_3_4 = 3 * (256 // 4)\n\n##### Function\ndef segmentSignals(signal, r_peaks_annot, normalization=True, person_id= None, file_id=None):\n    \n    \"\"\"\n    Segments signals based on the detected R-Peak\n    Args:\n        signal (numpy array): input signal\n        r_peaks_annot (int []): r-peak locations.\n        normalization (bool, optional): apply z-normalization or not? . Defaults to True.\n        person_id ([type], optional): [description]. Defaults to None.\n        file_id ([type], optional): [description]. Defaults to None.\n    Returns:\n            [tuple(numpy array,numpy array)]: segmented signals and refined r-peaks\n    \"\"\"\n    def refine_rpeaks(signal, r_peaks):\n        \"\"\"\n        Refines the detected R-peaks. If the R-peak is slightly shifted, this assigns the \n        highest point R-peak.\n        Args:\n            signal (numpy array): input signal\n            r_peaks (int []): list of detected r-peaks\n        Returns:\n            [numpy array]: refined r-peaks\n        \"\"\"\n\n        r_peaks2 = np.array(r_peaks)            # make a copy\n        for i in range(len(r_peaks)):\n            r = r_peaks[i]          # current R-peak\n            small_segment = signal[max(0,r-100):min(len(signal),r+100)]         # consider the neighboring segment of R-peak\n            r_peaks2[i] = np.argmax(small_segment) - 100 + r_peaks[i]           # picking the highest point\n            r_peaks2[i] = min(r_peaks2[i],len(signal))                          # the detected R-peak shouldn't be outside the signal\n            r_peaks2[i] = max(r_peaks2[i],0)                                    # checking if it goes before zero    \n        return r_peaks2                     # returning the refined r-peak list\n    \n    segmented_signals = []                      # array containing the segmented beats\n    \n    r_peaks = np.array(r_peaks_annot)\n    r_peaks = refine_rpeaks(signal, r_peaks)\n    skip_len = 5 # Parameter to specify number of r_peaks in one signal\n    max_seq_len = 1280 # Parameter to specify maximum sequence length\n    \n    for r_curr in range(0,int(r_peaks.shape[0]-(skip_len-1)),skip_len):\n        if ((r_peaks[r_curr]-W_LEN_1_4)<0) or ((r_peaks[r_curr+(skip_len-1)]+W_LEN_3_4)>=len(signal)):           # not enough signal to segment\n            continue\n        segmented_signal = np.array(signal[r_peaks[r_curr]-W_LEN_1_4:r_peaks[r_curr+(skip_len-1)]+W_LEN_3_4])        # segmenting a heartbeat\n        segmented_signal = list(segmented_signal)\n        #print(segmented_signal.shape)\n        \n        if(len(segmented_signal) < 1280):\n            for m in range(int(1280-len(segmented_signal))): # Zero Padding\n                segmented_signal.append(0)\n        else:\n            segmented_signal = (segmented_signal[:int(max_seq_len)])\n            \n        segmented_signal = np.array(segmented_signal)\n        \n        if(segmented_signal.shape != (1280,1)):    \n            segmented_signal = np.reshape(segmented_signal,(1280,1))\n            \n        if (normalization):             # Z-score normalization\n            if abs(np.std(segmented_signal))<1e-6:          # flat line ECG, will cause zero division error\n                continue\n            segmented_signal = (segmented_signal - np.mean(segmented_signal)) / np.std(segmented_signal)            \n              \n        #if not np.isnan(segmented_signal).any():                    # checking for nan, this will never happen\n            segmented_signals.append(segmented_signal)\n\n    return segmented_signals,r_peaks           # returning the segmented signals and the refined r-peaks","metadata":{"execution":{"iopub.status.busy":"2021-06-01T05:22:55.519383Z","iopub.execute_input":"2021-06-01T05:22:55.519759Z","iopub.status.idle":"2021-06-01T05:22:55.709792Z","shell.execute_reply.started":"2021-06-01T05:22:55.519717Z","shell.execute_reply":"2021-06-01T05:22:55.708708Z"},"trusted":true},"execution_count":3,"outputs":[]},{"cell_type":"code","source":"###### Test\nmit_dbs_path = '../input/mitbih-database'\nlist_seg_sig = []\nfor i in range(0,96,2): # Loop over all the files\n    print(i)\n    rec_file_path = os.path.join(mit_dbs_path,str(np.sort(os.listdir(mit_dbs_path))[i])) # Path Selection\n    attr_file_path = os.path.join(mit_dbs_path,str(np.sort(os.listdir(mit_dbs_path))[i+1])) # Path Selction \n    rec_file = data_read_mit(rec_file_path)\n    r_peaks = feature_extractor(attr_file_path)\n    \n    seg_sig,r_peak = segmentSignals(rec_file,list(r_peaks))\n    #seg_sig = np.array(seg_sig)\n    \n    for seg_sig_curr in seg_sig:\n        #print(np.array(seg_sig_curr).shape)\n        list_seg_sig.append(seg_sig_curr)\n        \nfor i in range(10):\n    plt.plot(np.arange(1280),list_seg_sig[i])\n    plt.show()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"###### Looping for Reading the Entire Dataset\n\n! mkdir './5_Beat_Ecg_MITBIH' # Generating major database of datasets\ncurrent_index = 1\n\nmit_dbs_path = '../input/mitbih-database'\nfor i in range(0,96,2): # Loop over all the files\n    print(i)\n    print(np.sort(os.listdir(mit_dbs_path))[i])\n    rec_file_path = os.path.join(mit_dbs_path,str(np.sort(os.listdir(mit_dbs_path))[i])) # Path Selection\n    attr_file_path = os.path.join(mit_dbs_path,str(np.sort(os.listdir(mit_dbs_path))[i+1])) # Path Selction\n    \n    signal_current = data_read_mit(rec_file_path) # Current ECG Signal\n    r_peaks_current = feature_extractor(attr_file_path) # R-peaks\n    seg_signal_current,new_r_peaks = (segmentSignals(signal_current,list(r_peaks_current))) # Segmented ECG Signals\n    #seg_signal_current = np.array(seg_signal_current)\n    #print(seg_signal_current.shape[0])\n    \n    if(i == 48):\n        current_index = current_index-1\n        current_storage_path = './5_Beat_Ecg_MITBIH'+'/person'+str(current_index)\n        #Path(current_storage_path).mkdir(parents=True, exist_ok=True)\n    \n        for j in range(len(seg_signal_current)):\n            file_name_current = current_storage_path+'/Extra'+str(j)\n            np.savez_compressed(file_name_current,seg_signal_current[j])\n            \n        current_index = current_index+1\n    \n    else:\n        current_storage_path = './5_Beat_Ecg_MITBIH'+'/person'+str(current_index)\n        Path(current_storage_path).mkdir(parents=True, exist_ok=True)\n    \n        for j in range(len(seg_signal_current)):\n            file_name_current = current_storage_path+'/'+str(j)\n            np.savez_compressed(file_name_current,seg_signal_current[j])\n            \n        current_index = current_index+1","metadata":{"execution":{"iopub.status.busy":"2021-06-01T05:22:58.622670Z","iopub.execute_input":"2021-06-01T05:22:58.623024Z","iopub.status.idle":"2021-06-01T05:27:53.163755Z","shell.execute_reply.started":"2021-06-01T05:22:58.622992Z","shell.execute_reply":"2021-06-01T05:27:53.162568Z"},"trusted":true},"execution_count":4,"outputs":[{"name":"stdout","text":"0\n100.csv\n","output_type":"stream"},{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/ipykernel_launcher.py:113: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n","output_type":"stream"},{"name":"stdout","text":"2\n101.csv\n4\n102.csv\n6\n103.csv\n8\n104.csv\n10\n105.csv\n12\n106.csv\n14\n107.csv\n16\n108.csv\n18\n109.csv\n20\n111.csv\n22\n112.csv\n24\n113.csv\n26\n114.csv\n28\n115.csv\n30\n116.csv\n32\n117.csv\n34\n118.csv\n36\n119.csv\n38\n121.csv\n40\n122.csv\n42\n123.csv\n44\n124.csv\n46\n200.csv\n48\n201.csv\n50\n202.csv\n52\n203.csv\n54\n205.csv\n56\n207.csv\n58\n208.csv\n60\n209.csv\n62\n210.csv\n64\n212.csv\n66\n213.csv\n68\n214.csv\n70\n215.csv\n72\n217.csv\n74\n219.csv\n76\n220.csv\n78\n221.csv\n80\n222.csv\n82\n223.csv\n84\n228.csv\n86\n230.csv\n88\n231.csv\n90\n232.csv\n92\n233.csv\n94\n234.csv\n","output_type":"stream"}]},{"cell_type":"code","source":"###### Creation of Numpy Arrays\n##### Defining Essentials\ndata_folder = './5_Beat_Ecg_MITBIH'\nX_train = []\nX_dev = []\ny_train = []     \ny_dev = []\n\n##### Looping Over to populate the dataset\nfor index,sub_data_folder in enumerate(np.sort(os.listdir(data_folder))):\n    sub_data_folder_path = os.path.join(data_folder,sub_data_folder)\n    \n    #if(index <= 34):\n        \n    #for idx,item in enumerate(np.sort(os.listdir(sub_data_folder_path))): # Looping Over a person's folder\n    #    item_path = os.path.join(sub_data_folder_path,item)\n\n        #### Train on Past Test on Present (TPTP)\n        #if(idx <= int(len(os.listdir(sub_data_folder_path))//2)):\n        #    X_train.append(np.load(item_path,allow_pickle=True)['arr_0'])\n        #    y_train.append(index)\n        #else:\n        #    X_dev.append(np.load(item_path,allow_pickle=True)['arr_0'])\n        #    y_dev.append(index)\n\n        #### Alternate Training Strategy (ALT)\n        #if(idx%2 == 0 and  idx != 1):\n        #    X_train.append(np.load(item_path,allow_pickle=True)['arr_0'])\n        #    y_train.append(index-35)\n        #else:\n        #    X_dev.append(np.load(item_path,allow_pickle=True)['arr_0'])\n        #    y_dev.append(index-35)\n\n    #### Random Training Strategy (RAND)\n    dir_sub = list(np.sort(os.listdir(sub_data_folder_path)))\n    dir_shuffled = shuffle(dir_sub)\n    #print(dir_shuffled)\n    \n    for idx,item in enumerate(dir_shuffled): # Looping Over a person's folder\n        item_path = os.path.join(sub_data_folder_path,item)\n\n        if(idx <= int(len(dir_shuffled)//2)):\n            X_train.append(np.load(item_path,allow_pickle=True)['arr_0'])\n            y_train.append(index)\n        else:\n            X_dev.append(np.load(item_path,allow_pickle=True)['arr_0'])\n            y_dev.append(index)    \n        \n    print('Person'+' '+str(index+1)+'s data taken')\n            \n##### Creation of Numpy Arrays\nX_train = np.array(X_train)\nX_dev = np.array(X_dev)\ny_train = np.array(y_train)\ny_dev = np.array(y_dev)\n\n##### Shuffling Dataset\nX_train,y_train = shuffle(X_train,y_train,random_state=23)\nX_dev,y_dev = shuffle(X_dev,y_dev,random_state=23)\n\n##### Saving Dataset\nnp.savez_compressed('./X_train_RAND_MITBIH.npz',X_train)\nnp.savez_compressed('./X_dev_RAND_MITBIH.npz',X_dev)\nnp.savez_compressed('./y_train_RAND_MITBIH.npz',y_train)\nnp.savez_compressed('./y_dev_RAND_MITBIH.npz',y_dev)","metadata":{"execution":{"iopub.status.busy":"2021-06-01T05:30:18.177475Z","iopub.execute_input":"2021-06-01T05:30:18.177850Z","iopub.status.idle":"2021-06-01T05:33:19.822146Z","shell.execute_reply.started":"2021-06-01T05:30:18.177818Z","shell.execute_reply":"2021-06-01T05:33:19.821048Z"},"trusted":true},"execution_count":8,"outputs":[{"name":"stdout","text":"Person 1s data taken\nPerson 2s data taken\nPerson 3s data taken\nPerson 4s data taken\nPerson 5s data taken\nPerson 6s data taken\nPerson 7s data taken\nPerson 8s data taken\nPerson 9s data taken\nPerson 10s data taken\nPerson 11s data taken\nPerson 12s data taken\nPerson 13s data taken\nPerson 14s data taken\nPerson 15s data taken\nPerson 16s data taken\nPerson 17s data taken\nPerson 18s data taken\nPerson 19s data taken\nPerson 20s data taken\nPerson 21s data taken\nPerson 22s data taken\nPerson 23s data taken\nPerson 24s data taken\nPerson 25s data taken\nPerson 26s data taken\nPerson 27s data taken\nPerson 28s data taken\nPerson 29s data taken\nPerson 30s data taken\nPerson 31s data taken\nPerson 32s data taken\nPerson 33s data taken\nPerson 34s data taken\nPerson 35s data taken\nPerson 36s data taken\nPerson 37s data taken\nPerson 38s data taken\nPerson 39s data taken\nPerson 40s data taken\nPerson 41s data taken\nPerson 42s data taken\nPerson 43s data taken\nPerson 44s data taken\nPerson 45s data taken\nPerson 46s data taken\nPerson 47s data taken\n","output_type":"stream"}]},{"cell_type":"code","source":"##### Loading Dataset - ALT\n#X_train = np.array(np.load('../input/5beat-ecg-identification-mitbih/X_train.npz',allow_pickle=True)['arr_0'],dtype=np.float16)\n#X_dev = np.array(np.load('../input/5beat-ecg-identification-mitbih/X_dev.npz',allow_pickle=True)['arr_0'],dtype=np.float16)\n#y_train = np.load('../input/5beat-ecg-identification-mitbih/y_train.npz',allow_pickle=True)['arr_0']\n#y_dev = np.load('../input/5beat-ecg-identification-mitbih/y_dev.npz',allow_pickle=True)['arr_0']\n\n##### Loading Dataset - TPTP\n#X_train = np.array(np.load('../input/ecg-tptp-mitbih-final/X_train_TPTP_MITBIH.npz',allow_pickle=True)['arr_0'],dtype=np.float16)\n#X_dev = np.array(np.load('../input/ecg-tptp-mitbih-final/X_dev_TPTP_MITBIH.npz',allow_pickle=True)['arr_0'],dtype=np.float16)\n#y_train = np.load('../input/ecg-tptp-mitbih-final/y_train_TPTP_MITBIH.npz',allow_pickle=True)['arr_0']\n#y_dev = np.load('../input/ecg-tptp-mitbih-final/y_dev_TPTP_MITBIH.npz',allow_pickle=True)['arr_0']\n                            \n##### Loading Dataset -  OSV                                           \n#X_train = np.array(np.load('../input/ecg-osv-alt-7525-mitbih/X_train_OSV_75-25_ALT_MITBIH.npz',allow_pickle=True)['arr_0'],dtype=np.float16)\n#X_dev = np.array(np.load('../input/ecg-osv-alt-7525-mitbih/X_dev_OSV_75-25_ALT_MITBIH.npz',allow_pickle=True)['arr_0'],dtype=np.float16)\n#y_train = np.load('../input/ecg-osv-alt-7525-mitbih/y_train_OSV_75-25_ALT_MITBIH.npz',allow_pickle=True)['arr_0']\n#y_dev = np.load('../input/ecg-osv-alt-7525-mitbih/y_dev_OSV_75-25_ALT_MITBIH.npz',allow_pickle=True)['arr_0']    \n     \n##### Loading Dataset - OSV_Test                                                   \n#X_train = np.array(np.load('../input/ecg-osv-alt-7525-mitbih-test/X_train_OSV_75-25_ALT_MITBIH_Test.npz',allow_pickle=True)['arr_0'],dtype=np.float16)\n#X_dev = np.array(np.load('../input/ecg-osv-alt-7525-mitbih-test/X_dev_OSV_75-25_ALT_MITBIH_Test.npz',allow_pickle=True)['arr_0'],dtype=np.float16)\n#y_train = np.load('../input/ecg-osv-alt-7525-mitbih-test/y_train_OSV_75-25_ALT_MITBIH_Test.npz',allow_pickle=True)['arr_0']\n#y_dev = np.load('../input/ecg-osv-alt-7525-mitbih-test/y_dev_OSV_75-25_ALT_MITBIH_Test.npz',allow_pickle=True)['arr_0']\n\n##### Loading Dataset - RAND\nX_train = np.array(np.load('./X_train_RAND_MITBIH.npz',allow_pickle=True)['arr_0'],dtype=np.float16)\nX_dev = np.array(np.load('./X_dev_RAND_MITBIH.npz',allow_pickle=True)['arr_0'],dtype=np.float16)\ny_train = np.load('./y_train_RAND_MITBIH.npz',allow_pickle=True)['arr_0']\ny_dev = np.load('./y_dev_RAND_MITBIH.npz',allow_pickle=True)['arr_0']","metadata":{"execution":{"iopub.status.busy":"2021-06-01T05:34:26.597916Z","iopub.execute_input":"2021-06-01T05:34:26.598318Z","iopub.status.idle":"2021-06-01T05:35:20.610184Z","shell.execute_reply.started":"2021-06-01T05:34:26.598286Z","shell.execute_reply":"2021-06-01T05:35:20.609043Z"},"trusted":true},"execution_count":9,"outputs":[]},{"cell_type":"code","source":"##### Converting Labels to Categorical Format\ny_train_ohot = tf.keras.utils.to_categorical(y_train)\ny_dev_ohot = tf.keras.utils.to_categorical(y_dev)","metadata":{"execution":{"iopub.status.busy":"2021-06-01T05:35:20.612280Z","iopub.execute_input":"2021-06-01T05:35:20.612691Z","iopub.status.idle":"2021-06-01T05:35:20.618750Z","shell.execute_reply.started":"2021-06-01T05:35:20.612647Z","shell.execute_reply":"2021-06-01T05:35:20.617656Z"},"trusted":true},"execution_count":10,"outputs":[]},{"cell_type":"code","source":"##### Testing Dataset Validity\nfor i in range(100):\n    \n    if(y_dev[i]==1):\n    #### Training Set\n        plt.plot(np.arange(0,1280),X_dev[i])\n        plt.show()\n        print('Class of the ECG:-'+' '+str(y_dev[i]))\n\n        #### Dev Set\n        #plt.plot(np.arange(0,256),X_dev[i])\n        #plt.show()\n        #print('Class of the ECG:-'+' '+str(y_dev[i]))","metadata":{"execution":{"iopub.status.busy":"2021-06-01T05:35:20.620688Z","iopub.execute_input":"2021-06-01T05:35:20.621103Z","iopub.status.idle":"2021-06-01T05:35:21.091702Z","shell.execute_reply.started":"2021-06-01T05:35:20.621061Z","shell.execute_reply":"2021-06-01T05:35:21.090526Z"},"trusted":true},"execution_count":11,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"name":"stdout","text":"Class of the ECG:- 1\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"name":"stdout","text":"Class of the ECG:- 1\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"name":"stdout","text":"Class of the ECG:- 1\n","output_type":"stream"}]},{"cell_type":"markdown","source":"# Model Making","metadata":{}},{"cell_type":"markdown","source":"## Self-Calibrated Convolutions","metadata":{}},{"cell_type":"code","source":"###### Model Development : Self-Calibrated \n\n##### Defining Self-Calibrated Block\n\nrate_regularizer = 1e-5\nclass self_cal_Conv1D(tf.keras.layers.Layer):\n\n    \"\"\" \n    This is inherited class from keras.layers and shall be instatition of self-calibrated convolutions\n    \"\"\"\n    \n    def __init__(self,num_filters,kernel_size,num_features):\n    \n        #### Defining Essentials\n        super().__init__()\n        self.num_filters = num_filters\n        self.kernel_size = kernel_size\n        self.num_features = num_features # Number of Channels in Input\n\n        #### Defining Layers\n        self.conv2 = tf.keras.layers.Conv1D(self.num_features/2,self.kernel_size,padding='same',kernel_regularizer=tf.keras.regularizers.l2(rate_regularizer),dtype='float32',activation='relu')\n        self.conv3 = tf.keras.layers.Conv1D(self.num_features/2,self.kernel_size,padding='same',kernel_regularizer=tf.keras.regularizers.l2(rate_regularizer),dtype='float32',activation='relu')\n        self.conv4 = tf.keras.layers.Conv1D(self.num_filters/2,self.kernel_size,padding='same',activation='relu',kernel_regularizer=tf.keras.regularizers.l2(rate_regularizer),dtype='float32')\n        self.conv1 = tf.keras.layers.Conv1D(self.num_filters/2,self.kernel_size,padding='same',activation='relu',kernel_regularizer=tf.keras.regularizers.l2(rate_regularizer),dtype='float32')\n        self.upsample = tf.keras.layers.Conv1DTranspose(filters=int(self.num_features/2),kernel_size=5,strides=5)\n        #self.attention_layer = tf.keras.layers.Attention()\n        #self.lstm = tf.keras.layers.LSTM(int(self.num_features/2),return_sequences=True)\n        #self.layernorm = tf.keras.layers.LayerNormalization()\n    \n    def get_config(self):\n\n        config = super().get_config().copy()\n        config.update({\n            'num_filters': self.num_filters,\n            'kernel_size': self.kernel_size,\n            'num_features': self.num_features\n        })\n        return config\n    \n    \n    def call(self,X):\n       \n        \"\"\"\n          INPUTS : 1) X - Input Tensor of shape (batch_size,sequence_length,num_features)\n          OUTPUTS : 1) X - Output Tensor of shape (batch_size,sequence_length,num_features)\n        \"\"\"\n        \n        #### Dimension Extraction\n        b_s = (X.shape)[0] \n        seq_len = (X.shape)[1]\n        num_features = (X.shape)[2]\n        \n        #### Channel-Wise Division\n        X_attention = X[:,:,0:int(self.num_features/2)]\n        X_global = X[:,:,int(self.num_features/2):]\n        \n        #### Self Calibration Block\n\n        ### Local Feature Detection\n\n        ## Down-Sampling\n        #x1 = X_attention[:,0:int(seq_len/5),:]\n        #x2 = X_attention[:,int(seq_len/5):int(seq_len*(2/5)),:]\n        #x3 = X_attention[:,int(seq_len*(2/5)):int(seq_len*(3/5)),:]\n        #x4 = X_attention[:,int(seq_len*(3/5)):int(seq_len*(4/5)),:]\n        #x5 = X_attention[:,int(seq_len*(4/5)):seq_len,:]\n        x_down_sampled = tf.keras.layers.AveragePooling1D(pool_size=5,strides=5)(X_attention)\n        \n        ## Convoluting Down Sampled Sequence \n        #x1 = self.conv2(x1)\n        #x2 = self.conv2(x2)\n        #x3 = self.conv2(x3)\n        #x4 = self.conv2(x4)\n        #x5 = self.conv2(x5)\n        x_down_conv = self.conv2(x_down_sampled)\n        #x_down_feature = self.attention_layer([x_down_sampled,x_down_sampled])\n        #x_down_feature = self.lstm(x_down_sampled)\n        #x_down_feature = self.layernorm(x_down_feature)\n        \n        ## Up-Sampling\n        x_down_upsampled = self.upsample(x_down_conv)   \n        #X_local_upsampled = tf.keras.layers.concatenate([x1,x2,x3,x4,x5],axis=1)\n\n        ## Local-CAM\n        X_local = X_attention + x_down_upsampled  #X_local_upsampled\n\n        ## Local Importance \n        X_2 = tf.keras.activations.sigmoid(X_local)\n\n        ### Self-Calibration\n\n        ## Global Convolution\n        X_3 = self.conv3(X_attention)\n\n        ## Attention Determination\n        X_attention = tf.math.multiply(X_2,X_3)\n\n        #### Self-Calibration Feature Extraction\n        X_4 = self.conv4(X_attention)\n\n        #### Normal Feature Extraction\n        X_1 = self.conv1(X_global)\n\n        #### Concatenating and Returning Output\n        return (tf.keras.layers.concatenate([X_1,X_4],axis=2))","metadata":{"execution":{"iopub.status.busy":"2021-06-01T05:35:43.707815Z","iopub.execute_input":"2021-06-01T05:35:43.708211Z","iopub.status.idle":"2021-06-01T05:35:43.725765Z","shell.execute_reply.started":"2021-06-01T05:35:43.708174Z","shell.execute_reply":"2021-06-01T05:35:43.724596Z"},"trusted":true},"execution_count":12,"outputs":[]},{"cell_type":"markdown","source":"# Transformer","metadata":{}},{"cell_type":"code","source":"def get_angles(pos, i, d_model):\n    angle_rates = 1 / np.power(10000, (2 * (i//2)) / np.float32(d_model))\n    return pos * angle_rates\n\ndef positional_encoding(position, d_model):\n    angle_rads = get_angles(np.arange(position)[:, np.newaxis],\n                          np.arange(d_model)[np.newaxis, :],\n                          d_model)\n  \n  # apply sin to even indices in the array; 2i\n    angle_rads[:, 0::2] = np.sin(angle_rads[:, 0::2])\n  \n  # apply cos to odd indices in the array; 2i+1\n    angle_rads[:, 1::2] = np.cos(angle_rads[:, 1::2])\n    \n    pos_encoding = angle_rads[np.newaxis, ...]\n    \n    return tf.cast(pos_encoding, dtype=tf.float32)\n\ndef create_padding_mask(seq):\n    seq = tf.cast(tf.math.equal(seq, 0), tf.float32)\n  \n    # add extra dimensions to add the padding\n    # to the attention logits. \n    return seq[:, tf.newaxis, tf.newaxis, :]  # (batch_size, 1, 1, seq_len)\n\ndef scaled_dot_product_attention(q, k, v, mask):\n    \"\"\"Calculate the attention weights.\n    q, k, v must have matching leading dimensions.\n    k, v must have matching penultimate dimension, i.e.: seq_len_k = seq_len_v.\n    The mask has different shapes depending on its type(padding or look ahead) \n    but it must be broadcastable for addition.\n\n    Args:\n    q: query shape == (..., seq_len_q, depth)\n    k: key shape == (..., seq_len_k, depth)\n    v: value shape == (..., seq_len_v, depth_v)\n    mask: Float tensor with shape broadcastable \n          to (..., seq_len_q, seq_len_k). Defaults to None.\n\n    Returns:\n    output, attention_weights\n    \"\"\"\n\n    matmul_qk = tf.matmul(q, k, transpose_b=True)  # (..., seq_len_q, seq_len_k)\n  \n    # scale matmul_qk\n    dk = tf.cast(tf.shape(k)[-1], tf.float32)\n    scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)\n\n    # add the mask to the scaled tensor.\n    if mask is not None:\n        scaled_attention_logits += (mask * -1e9)  \n\n    # softmax is normalized on the last axis (seq_len_k) so that the scores\n    # add up to 1.\n    attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1)  # (..., seq_len_q, seq_len_k)\n\n    output = tf.matmul(attention_weights, v)  # (..., seq_len_q, depth_v)\n\n    return output, attention_weights\n\nclass MultiHeadAttention(tf.keras.layers.Layer):\n    def __init__(self, d_model, num_heads):\n        super(MultiHeadAttention, self).__init__()\n        self.num_heads = num_heads\n        self.d_model = d_model\n\n        assert d_model % self.num_heads == 0\n\n        self.depth = d_model // self.num_heads\n\n        self.wq = tf.keras.layers.Dense(d_model)\n        self.wk = tf.keras.layers.Dense(d_model)\n        self.wv = tf.keras.layers.Dense(d_model)\n\n        self.dense = tf.keras.layers.Dense(d_model)\n\n    def get_config(self):\n        config = super(MultiHeadAttention, self).get_config().copy()\n        config.update({\n            'd_model': self.d_model,\n            'num_heads':self.num_heads\n        })\n        \n    def split_heads(self, x, batch_size):\n        \n        \"\"\"Split the last dimension into (num_heads, depth).\n        Transpose the result such that the shape is (batch_size, num_heads, seq_len, depth)\n        \"\"\"\n        x = tf.reshape(x, (batch_size, -1, self.num_heads, self.depth))\n        return tf.transpose(x, perm=[0, 2, 1, 3])\n    \n    def call(self, v, k, q, mask):\n        batch_size = tf.shape(q)[0]\n\n        q = self.wq(q)  # (batch_size, seq_len, d_model)\n        k = self.wk(k)  # (batch_size, seq_len, d_model)\n        v = self.wv(v)  # (batch_size, seq_len, d_model)\n\n        q = self.split_heads(q, batch_size)  # (batch_size, num_heads, seq_len_q, depth)\n        k = self.split_heads(k, batch_size)  # (batch_size, num_heads, seq_len_k, depth)\n        v = self.split_heads(v, batch_size)  # (batch_size, num_heads, seq_len_v, depth)\n\n        # scaled_attention.shape == (batch_size, num_heads, seq_len_q, depth)\n        # attention_weights.shape == (batch_size, num_heads, seq_len_q, seq_len_k)\n        scaled_attention, attention_weights = scaled_dot_product_attention(\n            q, k, v, mask)\n\n        scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3])  # (batch_size, seq_len_q, num_heads, depth)\n\n        concat_attention = tf.reshape(scaled_attention, \n                                      (batch_size, -1, self.d_model))  # (batch_size, seq_len_q, d_model)\n\n        output = self.dense(concat_attention)  # (batch_size, seq_len_q, d_model)\n\n        return output, attention_weights\n\ndef point_wise_feed_forward_network(d_model, dff):\n    return tf.keras.Sequential([\n      tf.keras.layers.Dense(dff, activation='relu'),  # (batch_size, seq_len, dff)\n      tf.keras.layers.Dense(d_model)  # (batch_size, seq_len, d_model)\n  ])\n\nclass Encoder(tf.keras.layers.Layer):\n    def __init__(self, num_layers, d_model, num_heads, dff,\n               maximum_position_encoding, rate=0.1):\n        super(Encoder, self).__init__()\n\n        self.d_model = d_model\n        self.num_layers = num_layers\n        self.num_heads = num_heads\n        self.dff = dff\n        self.maximum_position_encoding = maximum_position_encoding\n        self.rate = rate\n\n        #self.embedding = tf.keras.layers.Embedding(input_vocab_size, d_model)\n        self.pos_encoding = positional_encoding(maximum_position_encoding, \n                                                self.d_model)\n\n\n        self.enc_layers = [EncoderLayer(d_model, num_heads, dff, rate) \n                           for _ in range(num_layers)]\n\n        self.dropout = tf.keras.layers.Dropout(rate)\n        \n    def get_config(self):\n        config = super(Encoder, self).get_config().copy()\n        config.update({\n            'num_layers': self.num_layers,\n            'd_model': self.d_model,\n            'num_heads':self.num_heads,\n            'dff':self.dff,\n            'maximum_position_encoding':self.maximum_position_encoding,\n            'rate':self.rate  \n        })\n        \n    def call(self, x, training, mask):\n\n        seq_len = tf.shape(x)[1]\n\n        # adding embedding and position encoding.\n        #x = self.embedding(x)  # (batch_size, input_seq_len, d_model)\n        x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))\n        x += self.pos_encoding[:, :seq_len, :]\n\n        x = self.dropout(x, training=training)         \n\n        for i in range(self.num_layers):\n            x = self.enc_layers[i](x, training, mask)\n\n        return x  # (batch_size, input_seq_len, d_model)\n\nclass EncoderLayer(tf.keras.layers.Layer):\n    def __init__(self, d_model, num_heads, dff, rate=0.1):\n        super(EncoderLayer, self).__init__()\n        \n        self.d_model = d_model\n        self.num_heads = num_heads\n        self.dff = dff\n        self.rate = rate\n\n        self.mha = MultiHeadAttention(d_model, num_heads)\n        self.ffn = point_wise_feed_forward_network(d_model, dff)\n\n        self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n        self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n\n        self.dropout1 = tf.keras.layers.Dropout(rate)\n        self.dropout2 = tf.keras.layers.Dropout(rate)\n        \n    def get_config(self):\n        config = super(EncoderLayer, self).get_config().copy()\n        config.update({\n            'd_model': self.d_model,\n            'num_heads':self.num_heads,\n            'dff':self.dff,\n            'rate':self.rate  \n        })\n\n    def call(self, x, training, mask):\n\n        attn_output, _ = self.mha(x, x, x, mask)  # (batch_size, input_seq_len, d_model)\n        attn_output = self.dropout1(attn_output, training=training)\n        out1 = self.layernorm1(x + attn_output)  # (batch_size, input_seq_len, d_model)\n\n        ffn_output = self.ffn(out1)  # (batch_size, input_seq_len, d_model)\n        ffn_output = self.dropout2(ffn_output, training=training)\n        out2 = self.layernorm2(out1 + ffn_output)  # (batch_size, input_seq_len, d_model)\n    \n        return out2\n    \nclass Transformer(tf.keras.Model):\n    def __init__(self, num_layers, d_model, num_heads, dff, \n                 pe_input, rate=0.1):\n        super(Transformer, self).__init__()\n        \n        self.num_layers = num_layers\n        self.d_model = d_model\n        self.num_heads = num_heads\n        self.dff = dff\n        self.pe_input = pe_input\n        self.rate = rate\n        \n        self.encoder = Encoder(num_layers, d_model, num_heads, dff, \n                                pe_input, rate)\n        \n    def get_config(self):\n        config = super(Transformer,self).get_config().copy()\n        config.update({\n            'num_layers': self.num_layers,\n            'd_model': self.d_model,\n            'num_heads':self.num_heads,\n            'dff':self.dff,\n            'pe_input':self.pe_input,\n            'rate':self.rate  \n        })\n    \n    def call(self, inp, training, enc_padding_mask):\n        return self.encoder(inp, training, enc_padding_mask)","metadata":{"execution":{"iopub.status.busy":"2021-06-01T05:35:48.865044Z","iopub.execute_input":"2021-06-01T05:35:48.865461Z","iopub.status.idle":"2021-06-01T05:35:48.906040Z","shell.execute_reply.started":"2021-06-01T05:35:48.865427Z","shell.execute_reply":"2021-06-01T05:35:48.905264Z"},"trusted":true},"execution_count":13,"outputs":[]},{"cell_type":"markdown","source":"## ArcFace Loss","metadata":{}},{"cell_type":"code","source":"class ArcFace(tf.keras.layers.Layer):\n    \n    def __init__(self, n_classes, s, m,regularizer):\n        super().__init__()\n        self.n_classes = n_classes\n        self.s = s\n        self.m = m\n        self.regularizer = tf.keras.regularizers.get(regularizer)\n\n    def get_config(self):\n\n        config = super().get_config().copy()\n        config.update({\n            'n_classes': self.n_classes,\n            's': self.s,\n            'm': self.m,\n            'regularizer': self.regularizer\n        })\n        return config\n\n    def build(self, input_shape):\n        super(ArcFace, self).build(input_shape[0])\n        self.W = self.add_weight(name='W',\n                                shape=(input_shape[0][-1], self.n_classes),\n                                initializer='glorot_uniform',\n                                trainable=True\n                                )\n\n    def call(self, inputs):\n        x, y = inputs\n        c = tf.keras.backend.shape(x)[-1]\n        # normalize feature\n        x = tf.nn.l2_normalize(x, axis=1)\n        # normalize weights\n        W = tf.nn.l2_normalize(self.W, axis=0)\n        # dot product\n        logits = x @ W\n        # add margin\n        # clip logits to prevent zero division when backward\n        theta = tf.acos(tf.keras.backend.clip(logits, -1.0 + tf.keras.backend.epsilon(), 1.0 - tf.keras.backend.epsilon()))\n        target_logits = tf.cos(theta + self.m)\n        # sin = tf.sqrt(1 - logits**2)\n        # cos_m = tf.cos(logits)\n        # sin_m = tf.sin(logits)\n        # target_logits = logits * cos_m - sin * sin_m\n        #\n        logits = logits * (1 - y) + target_logits * y\n        # feature re-scale\n        logits *= self.s\n        out = tf.nn.softmax(logits)    \n        return out\n\n    def compute_output_shape(self, input_shape):\n        return (None, self.n_classes)","metadata":{"execution":{"iopub.status.busy":"2021-06-01T05:35:55.043477Z","iopub.execute_input":"2021-06-01T05:35:55.043822Z","iopub.status.idle":"2021-06-01T05:35:55.056502Z","shell.execute_reply.started":"2021-06-01T05:35:55.043791Z","shell.execute_reply":"2021-06-01T05:35:55.055228Z"},"trusted":true},"execution_count":14,"outputs":[]},{"cell_type":"markdown","source":"# Model Training","metadata":{}},{"cell_type":"code","source":"####### Phase-1 Models\n###### Defining Architecture\n\nwith tpu_strategy.scope():\n\n    ##### SC_Module \n\n    #### Defining Hyperparameters\n    num_layers = 2\n    d_model = 512\n    num_heads = 8\n    dff = 1024\n    max_seq_len = 1280 #X_train.shape[1]\n    pe_input = max_seq_len\n    rate = 0.5\n    num_features = 1\n    num_classes = 47\n\n    #### Defining Layers\n    Input_layer = tf.keras.layers.Input(shape=(max_seq_len,num_features))\n    self_conv1 = self_cal_Conv1D(128,3,128)\n    self_conv2 = self_cal_Conv1D(128,5,128) # Newly Added\n    self_conv3 = self_cal_Conv1D(256,3,128)\n    self_conv4 = self_cal_Conv1D(256,5,256) # Newly Added\n    self_conv5 = self_cal_Conv1D(512,3,256)\n    self_conv6 = self_cal_Conv1D(512,5,512) # Newly Added\n    self_conv7 = self_cal_Conv1D(1024,3,512)\n    self_conv8 = self_cal_Conv1D(1024,5,1024) # Newly Added\n    conv_initial = tf.keras.layers.Conv1D(32,3,padding='same',activation='relu')\n    conv_second = tf.keras.layers.Conv1D(64,3,padding='same',activation='relu')\n    conv_third = tf.keras.layers.Conv1D(128,3,padding='same',activation='relu')\n    transform_1 = tf.keras.layers.Conv1D(128,3,padding='same',kernel_initializer='lecun_normal', activation='selu')\n    transform_2 = tf.keras.layers.Conv1D(256,3,padding='same',kernel_initializer='lecun_normal', activation='selu')\n    transform_3 = tf.keras.layers.Conv1D(512,3,padding='same',kernel_initializer='lecun_normal', activation='selu')\n    transform_4 = tf.keras.layers.Conv1D(1024,3,padding='same',kernel_initializer='lecun_normal', activation='selu')\n    transformer = Transformer(num_layers,d_model,num_heads,dff,pe_input,rate)\n    gap_layer = tf.keras.layers.GlobalAveragePooling1D()\n    arc_logit_layer = ArcFace(47,30.0,0.5,tf.keras.regularizers.l2(1e-4))\n\n    #### Defining Architecture\n    ### Input Layer\n    Inputs = Input_layer\n    Input_Labels = tf.keras.layers.Input(shape=(num_classes,))\n\n    ### Initial Convolutional Layers\n    conv_initial = conv_initial(Inputs)\n    #conv_initial = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(conv_initial)\n    \n    conv_second = conv_second(conv_initial)\n    #conv_second = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(conv_second)\n    \n    conv_third = conv_third(conv_second)\n    conv_third = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(conv_third)\n    #mask = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(Inputs)\n\n    ### 1st Residual Block\n    transform_1 = transform_1(conv_third)\n    conv1 = self_conv1(conv_third)\n    conv2 = self_conv2(conv1)\n    conv2 = tf.keras.layers.Add()([conv2,transform_1])\n    conv2 = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(conv2)\n    #mask = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(mask)    \n\n    ### 2nd Residual Block\n    transform_2 = transform_2(conv2)\n    conv3 = self_conv3(conv2)\n    conv4 = self_conv4(conv3)\n    conv4 = tf.keras.layers.Add()([conv4,transform_2])\n    conv4 = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(conv4)\n    #mask = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(mask)\n\n    ### 3rd Residual Block\n    transform_3 = transform_3(conv4)\n    conv5 = self_conv5(conv4)\n    conv6 = self_conv6(conv5)\n    conv6 = tf.keras.layers.Add()([conv6,transform_3])\n    #conv6 = tf.keras.layers.MaxPool1D(pool_size=2,strides=2)(conv6)\n\n    ### 4th Residual Block\n    #transform_4 = transform_4(conv6)\n    #conv7 = self_conv7(conv6)\n    #conv8 = self_conv8(conv7)\n    #conv8 = tf.keras.layers.Add()([conv8,transform_4])\n\n    ### Transformer\n    ## Wide-Head Attention Model\n    #tx_embedding = tf.keras.layers.Lambda(PE_Layer)(Inputs)\n    #tx_embedding = tf.keras.layers.Dropout(rate)(tx_embedding,training=True)\n    #mask_reshaped = tf.keras.layers.Reshape((max_seq_len,))(Inputs)\n    #encoder_op1 = encoder_block1(tx_embedding,mask_reshaped)\n    #encoder_op2 = encoder_block2(encoder_op1,mask_reshaped)\n\n    ## Narrow-Head Attention Model\n    #mask_reshaped = tf.keras.layers.Reshape((160,))(mask)\n    embeddings =  transformer(inp=conv6,enc_padding_mask=None)\n    #embeddings = transformer(inp=conv6,enc_padding_mask=create_padding_mask(mask))\n    #residual_embeddings = tf.keras.layers.Add()([conv6,embeddings])\n\n    ### Output Layers\n    ## Initial Layers\n    gap_op = gap_layer(embeddings)\n    dense1 = tf.keras.layers.Dense(256,activation='relu')(gap_op)\n    dropout1 = tf.keras.layers.Dropout(rate)(dense1)\n    \n    ## ArcFace Output Network\n    dense2 = tf.keras.layers.Dense(256,kernel_initializer='he_normal',\n                kernel_regularizer=tf.keras.regularizers.l2(1e-4))(dropout1)\n    ##dense2 = tf.keras.layers.BatchNormalization()(dense2)\n    dense3 = arc_logit_layer(([dense2,Input_Labels]))\n    \n    ## Softmax Output Network\n    #dense2 = tf.keras.layers.Dense(256,activation='relu')(dropout1)\n    ###dropout2 = tf.keras.layers.Dropout(rate)(dense2) # Not to be included\n    #dense3 = tf.keras.layers.Dense(35,activation='softmax')(dense2)\n\n    #### Compiling Architecture            \n    ### ArcFace Model Compilation\n    model = tf.keras.models.Model(inputs=[Inputs,Input_Labels],outputs=dense3)\n    ### Softmax Model Compilation\n    #model = tf.keras.models.Model(inputs=Inputs,outputs=dense3)\n    #model.load_weights('./RAND_MITBIH.h5')\n    model.compile(tf.keras.optimizers.Adam(lr=1e-4,clipnorm=1.0),loss='categorical_crossentropy',metrics=['accuracy'])\n\nmodel.summary()      \ntf.keras.utils.plot_model(model)\n##### Model Training \n\n#### Model Checkpointing\nfilepath = './RAND_MITBIH.h5'\ncheckpoint = tf.keras.callbacks.ModelCheckpoint(filepath,monitor='val_accuracy',save_best_only=True,mode='max',save_weights_only=True)\n\n#### Custom Learning Rate Schedule\n#def build_lrfn(lr_start=1e-4, lr_max=1e-3, \n#               lr_min=1e-6, lr_rampup_epochs=5, \n#               lr_sustain_epochs=0, lr_exp_decay=.87):\n#    lr_max = lr_max * tpu_strategy.num_replicas_in_sync\n\n#    def lrfn(epoch):\n#        if epoch < lr_rampup_epochs:\n#            lr = (lr_max - lr_start) / lr_rampup_epochs * epoch + lr_start\n#        elif epoch < lr_rampup_epochs + lr_sustain_epochs:\n#            lr = lr_max\n#        else:\n#            lr = (lr_max - lr_min) * lr_exp_decay**(epoch - lr_rampup_epochs - lr_sustain_epochs) + lr_min#\n#        return lr\n#    \n#    return lrfn\n\n#lrfn = build_lrfn()\n#lr_callback = tf.keras.callbacks.LearningRateScheduler(lrfn, verbose=1)\n#callback_list = [checkpoint,  lr_callback]\n\n#### Model Training\n#### Model Training\n### ArcFace Training\nhistory = model.fit((X_train,y_train_ohot),y_train_ohot,epochs=250,batch_size=128,\n                validation_data=((X_dev,y_dev_ohot),y_dev_ohot),validation_batch_size=128,\n               callbacks=checkpoint)\n\n### Softmax Training \n#history = model.fit(X_train,y_train_ohot,epochs=250,batch_size=128,\n#                validation_data=(X_dev,y_dev_ohot),validation_batch_size=128,\n#                callbacks=checkpoint)\n\n\n##### Plotting Metrics  \n#### Accuracy and Loss Plots \n\n### Accuracy\n#plt.plot(history.history['accuracy'])\n#plt.plot(history.history['val_accuracy'])\n#plt.title('Model Accuracy')\n#plt.ylabel('Accuracy')\n#plt.xlabel('Epoch')  \n#plt.legend(['Train', 'Validation'], loc='best')\n#plt.show()\n\n### Loss     \n#plt.plot(history.history['loss'])  \n#plt.plot(history.history['val_loss'])\n#plt.title('Model Loss')  \n#plt.ylabel('Loss')         \n#plt.xlabel('epoch')\n#plt.legend(['Train', 'Validation'], loc='best')   \n#plt.show()\n\n##### Saving Model            \n#model.save_weights('ECG_SCNRNet.h5'  ","metadata":{"execution":{"iopub.status.busy":"2021-06-01T05:44:18.919294Z","iopub.execute_input":"2021-06-01T05:44:18.919729Z","iopub.status.idle":"2021-06-01T06:04:32.714324Z","shell.execute_reply.started":"2021-06-01T05:44:18.919694Z","shell.execute_reply":"2021-06-01T06:04:32.713244Z"},"trusted":true},"execution_count":15,"outputs":[{"name":"stdout","text":"Model: \"model\"\n__________________________________________________________________________________________________\nLayer (type)                    Output Shape         Param #     Connected to                     \n==================================================================================================\ninput_1 (InputLayer)            [(None, 1280, 1)]    0                                            \n__________________________________________________________________________________________________\nconv1d_32 (Conv1D)              (None, 1280, 32)     128         input_1[0][0]                    \n__________________________________________________________________________________________________\nconv1d_33 (Conv1D)              (None, 1280, 64)     6208        conv1d_32[0][0]                  \n__________________________________________________________________________________________________\nconv1d_34 (Conv1D)              (None, 1280, 128)    24704       conv1d_33[0][0]                  \n__________________________________________________________________________________________________\nmax_pooling1d (MaxPooling1D)    (None, 640, 128)     0           conv1d_34[0][0]                  \n__________________________________________________________________________________________________\nself_cal__conv1d (self_cal_Conv (None, 640, 128)     69952       max_pooling1d[0][0]              \n__________________________________________________________________________________________________\nself_cal__conv1d_1 (self_cal_Co (None, 640, 128)     102720      self_cal__conv1d[0][0]           \n__________________________________________________________________________________________________\nconv1d_35 (Conv1D)              (None, 640, 128)     49280       max_pooling1d[0][0]              \n__________________________________________________________________________________________________\nadd (Add)                       (None, 640, 128)     0           self_cal__conv1d_1[0][0]         \n                                                                 conv1d_35[0][0]                  \n__________________________________________________________________________________________________\nmax_pooling1d_1 (MaxPooling1D)  (None, 320, 128)     0           add[0][0]                        \n__________________________________________________________________________________________________\nself_cal__conv1d_2 (self_cal_Co (None, 320, 256)     94656       max_pooling1d_1[0][0]            \n__________________________________________________________________________________________________\nself_cal__conv1d_3 (self_cal_Co (None, 320, 256)     410240      self_cal__conv1d_2[0][0]         \n__________________________________________________________________________________________________\nconv1d_36 (Conv1D)              (None, 320, 256)     98560       max_pooling1d_1[0][0]            \n__________________________________________________________________________________________________\nadd_1 (Add)                     (None, 320, 256)     0           self_cal__conv1d_3[0][0]         \n                                                                 conv1d_36[0][0]                  \n__________________________________________________________________________________________________\nmax_pooling1d_2 (MaxPooling1D)  (None, 160, 256)     0           add_1[0][0]                      \n__________________________________________________________________________________________________\nself_cal__conv1d_4 (self_cal_Co (None, 160, 512)     377728      max_pooling1d_2[0][0]            \n__________________________________________________________________________________________________\nself_cal__conv1d_5 (self_cal_Co (None, 160, 512)     1639680     self_cal__conv1d_4[0][0]         \n__________________________________________________________________________________________________\nconv1d_37 (Conv1D)              (None, 160, 512)     393728      max_pooling1d_2[0][0]            \n__________________________________________________________________________________________________\nadd_2 (Add)                     (None, 160, 512)     0           self_cal__conv1d_5[0][0]         \n                                                                 conv1d_37[0][0]                  \n__________________________________________________________________________________________________\ntransformer (Transformer)       (None, 160, 512)     4205568     add_2[0][0]                      \n__________________________________________________________________________________________________\nglobal_average_pooling1d (Globa (None, 512)          0           transformer[0][0]                \n__________________________________________________________________________________________________\ndense_12 (Dense)                (None, 256)          131328      global_average_pooling1d[0][0]   \n__________________________________________________________________________________________________\ndropout_5 (Dropout)             (None, 256)          0           dense_12[0][0]                   \n__________________________________________________________________________________________________\ndense_13 (Dense)                (None, 256)          65792       dropout_5[0][0]                  \n__________________________________________________________________________________________________\ninput_2 (InputLayer)            [(None, 47)]         0                                            \n__________________________________________________________________________________________________\narc_face (ArcFace)              (None, 47)           12032       dense_13[0][0]                   \n                                                                 input_2[0][0]                    \n==================================================================================================\nTotal params: 7,682,304\nTrainable params: 7,682,304\nNon-trainable params: 0\n__________________________________________________________________________________________________\nEpoch 1/250\n89/89 [==============================] - 51s 247ms/step - loss: 18.7499 - accuracy: 0.0000e+00 - val_loss: 17.2207 - val_accuracy: 0.0000e+00\nEpoch 2/250\n89/89 [==============================] - 5s 51ms/step - loss: 17.2588 - accuracy: 0.0000e+00 - val_loss: 15.3869 - val_accuracy: 0.0000e+00\nEpoch 3/250\n89/89 [==============================] - 5s 51ms/step - loss: 15.5349 - accuracy: 7.6255e-04 - val_loss: 13.6798 - val_accuracy: 0.0637\nEpoch 4/250\n89/89 [==============================] - 4s 50ms/step - loss: 13.6930 - accuracy: 0.0144 - val_loss: 11.4090 - val_accuracy: 0.1484\nEpoch 5/250\n89/89 [==============================] - 4s 50ms/step - loss: 11.8948 - accuracy: 0.0375 - val_loss: 9.8249 - val_accuracy: 0.2677\nEpoch 6/250\n89/89 [==============================] - 4s 51ms/step - loss: 10.0804 - accuracy: 0.0958 - val_loss: 7.0396 - val_accuracy: 0.3922\nEpoch 7/250\n89/89 [==============================] - 5s 51ms/step - loss: 8.3737 - accuracy: 0.1754 - val_loss: 5.1296 - val_accuracy: 0.5480\nEpoch 8/250\n89/89 [==============================] - 5s 51ms/step - loss: 6.8123 - accuracy: 0.2732 - val_loss: 4.1651 - val_accuracy: 0.6569\nEpoch 9/250\n89/89 [==============================] - 4s 50ms/step - loss: 5.5428 - accuracy: 0.3620 - val_loss: 3.5184 - val_accuracy: 0.7204\nEpoch 10/250\n89/89 [==============================] - 4s 50ms/step - loss: 4.4723 - accuracy: 0.4631 - val_loss: 2.3843 - val_accuracy: 0.7913\nEpoch 11/250\n89/89 [==============================] - 4s 51ms/step - loss: 3.6473 - accuracy: 0.5448 - val_loss: 1.8255 - val_accuracy: 0.8722\nEpoch 12/250\n89/89 [==============================] - 4s 51ms/step - loss: 3.1189 - accuracy: 0.5946 - val_loss: 1.4534 - val_accuracy: 0.8896\nEpoch 13/250\n89/89 [==============================] - 4s 51ms/step - loss: 2.6404 - accuracy: 0.6510 - val_loss: 1.2333 - val_accuracy: 0.9168\nEpoch 14/250\n89/89 [==============================] - 4s 50ms/step - loss: 2.1627 - accuracy: 0.7110 - val_loss: 1.2852 - val_accuracy: 0.9207\nEpoch 15/250\n89/89 [==============================] - 5s 51ms/step - loss: 2.0422 - accuracy: 0.7321 - val_loss: 1.0719 - val_accuracy: 0.9366\nEpoch 16/250\n89/89 [==============================] - 5s 51ms/step - loss: 1.6991 - accuracy: 0.7711 - val_loss: 1.1121 - val_accuracy: 0.9327\nEpoch 17/250\n89/89 [==============================] - 4s 51ms/step - loss: 1.6916 - accuracy: 0.7870 - val_loss: 1.0030 - val_accuracy: 0.9368\nEpoch 18/250\n89/89 [==============================] - 4s 50ms/step - loss: 1.5256 - accuracy: 0.8081 - val_loss: 1.0787 - val_accuracy: 0.9323\nEpoch 19/250\n89/89 [==============================] - 5s 57ms/step - loss: 1.4250 - accuracy: 0.8245 - val_loss: 0.8071 - val_accuracy: 0.9567\nEpoch 20/250\n89/89 [==============================] - 5s 51ms/step - loss: 1.1961 - accuracy: 0.8488 - val_loss: 0.8693 - val_accuracy: 0.9528\nEpoch 21/250\n89/89 [==============================] - 4s 50ms/step - loss: 1.1723 - accuracy: 0.8519 - val_loss: 0.7714 - val_accuracy: 0.9617\nEpoch 22/250\n89/89 [==============================] - 4s 50ms/step - loss: 1.1557 - accuracy: 0.8591 - val_loss: 0.6910 - val_accuracy: 0.9668\nEpoch 23/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.9721 - accuracy: 0.8794 - val_loss: 0.7870 - val_accuracy: 0.9630\nEpoch 24/250\n89/89 [==============================] - 4s 51ms/step - loss: 1.0517 - accuracy: 0.8712 - val_loss: 0.6306 - val_accuracy: 0.9693\nEpoch 25/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.9757 - accuracy: 0.8834 - val_loss: 0.7231 - val_accuracy: 0.9610\nEpoch 26/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.8240 - accuracy: 0.8935 - val_loss: 0.7641 - val_accuracy: 0.9594\nEpoch 27/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.8265 - accuracy: 0.8976 - val_loss: 0.5868 - val_accuracy: 0.9697\nEpoch 28/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.7640 - accuracy: 0.9043 - val_loss: 0.7005 - val_accuracy: 0.9629\nEpoch 29/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.8102 - accuracy: 0.9068 - val_loss: 0.7581 - val_accuracy: 0.9638\nEpoch 30/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.9008 - accuracy: 0.9011 - val_loss: 0.5412 - val_accuracy: 0.9728\nEpoch 31/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.6881 - accuracy: 0.9161 - val_loss: 0.6376 - val_accuracy: 0.9710\nEpoch 32/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.6446 - accuracy: 0.9188 - val_loss: 0.6565 - val_accuracy: 0.9680\nEpoch 33/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.5667 - accuracy: 0.9282 - val_loss: 0.6133 - val_accuracy: 0.9728\nEpoch 34/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.6004 - accuracy: 0.9279 - val_loss: 0.4511 - val_accuracy: 0.9796\nEpoch 35/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.5423 - accuracy: 0.9299 - val_loss: 0.5269 - val_accuracy: 0.9765\nEpoch 36/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.5527 - accuracy: 0.9345 - val_loss: 0.5392 - val_accuracy: 0.9753\nEpoch 37/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.5254 - accuracy: 0.9322 - val_loss: 0.4968 - val_accuracy: 0.9772\nEpoch 38/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.5568 - accuracy: 0.9301 - val_loss: 0.4824 - val_accuracy: 0.9780\nEpoch 39/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.5177 - accuracy: 0.9341 - val_loss: 0.4262 - val_accuracy: 0.9793\nEpoch 40/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.4803 - accuracy: 0.9395 - val_loss: 0.5030 - val_accuracy: 0.9804\nEpoch 41/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.4416 - accuracy: 0.9420 - val_loss: 0.4976 - val_accuracy: 0.9765\nEpoch 42/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.4559 - accuracy: 0.9453 - val_loss: 0.4845 - val_accuracy: 0.9785\nEpoch 43/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.4662 - accuracy: 0.9454 - val_loss: 0.5898 - val_accuracy: 0.9726\nEpoch 44/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.4633 - accuracy: 0.9431 - val_loss: 0.4252 - val_accuracy: 0.9819\nEpoch 45/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.4188 - accuracy: 0.9530 - val_loss: 0.4713 - val_accuracy: 0.9798\nEpoch 46/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.4403 - accuracy: 0.9483 - val_loss: 0.4524 - val_accuracy: 0.9790\nEpoch 47/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.3934 - accuracy: 0.9557 - val_loss: 0.4193 - val_accuracy: 0.9828\nEpoch 48/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.3716 - accuracy: 0.9552 - val_loss: 0.4571 - val_accuracy: 0.9813\nEpoch 49/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.4022 - accuracy: 0.9499 - val_loss: 0.6234 - val_accuracy: 0.9751\nEpoch 50/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.4383 - accuracy: 0.9566 - val_loss: 0.4614 - val_accuracy: 0.9818\nEpoch 51/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.3912 - accuracy: 0.9545 - val_loss: 0.4657 - val_accuracy: 0.9800\nEpoch 52/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.3493 - accuracy: 0.9605 - val_loss: 0.3795 - val_accuracy: 0.9843\nEpoch 53/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.3924 - accuracy: 0.9559 - val_loss: 0.4091 - val_accuracy: 0.9839\nEpoch 54/250\n89/89 [==============================] - 5s 59ms/step - loss: 0.3153 - accuracy: 0.9634 - val_loss: 0.5661 - val_accuracy: 0.9763\nEpoch 55/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.3588 - accuracy: 0.9574 - val_loss: 0.3801 - val_accuracy: 0.9847\nEpoch 56/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.2972 - accuracy: 0.9659 - val_loss: 0.4470 - val_accuracy: 0.9815\nEpoch 57/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.3482 - accuracy: 0.9616 - val_loss: 0.5463 - val_accuracy: 0.9771\nEpoch 58/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.3031 - accuracy: 0.9660 - val_loss: 0.4574 - val_accuracy: 0.9807\nEpoch 59/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.3420 - accuracy: 0.9625 - val_loss: 0.4142 - val_accuracy: 0.9830\nEpoch 60/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.2853 - accuracy: 0.9661 - val_loss: 0.3899 - val_accuracy: 0.9842\nEpoch 61/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.3096 - accuracy: 0.9673 - val_loss: 0.3749 - val_accuracy: 0.9858\nEpoch 62/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.2852 - accuracy: 0.9673 - val_loss: 0.4105 - val_accuracy: 0.9829\nEpoch 63/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.2823 - accuracy: 0.9654 - val_loss: 0.4585 - val_accuracy: 0.9826\nEpoch 64/250\n89/89 [==============================] - 5s 53ms/step - loss: 0.3354 - accuracy: 0.9668 - val_loss: 0.4126 - val_accuracy: 0.9845\nEpoch 65/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.2673 - accuracy: 0.9681 - val_loss: 0.3310 - val_accuracy: 0.9877\nEpoch 66/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.2370 - accuracy: 0.9723 - val_loss: 0.3728 - val_accuracy: 0.9855\nEpoch 67/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.2389 - accuracy: 0.9723 - val_loss: 0.4963 - val_accuracy: 0.9821\nEpoch 68/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.2816 - accuracy: 0.9660 - val_loss: 0.3745 - val_accuracy: 0.9853\nEpoch 69/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.2519 - accuracy: 0.9745 - val_loss: 0.3770 - val_accuracy: 0.9854\nEpoch 70/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.2570 - accuracy: 0.9700 - val_loss: 0.3608 - val_accuracy: 0.9871\nEpoch 71/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.2505 - accuracy: 0.9717 - val_loss: 0.4079 - val_accuracy: 0.9858\nEpoch 72/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.2478 - accuracy: 0.9697 - val_loss: 0.4630 - val_accuracy: 0.9826\nEpoch 73/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.2632 - accuracy: 0.9723 - val_loss: 0.3778 - val_accuracy: 0.9863\nEpoch 74/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.2318 - accuracy: 0.9757 - val_loss: 0.3805 - val_accuracy: 0.9849\nEpoch 75/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.2418 - accuracy: 0.9718 - val_loss: 0.3332 - val_accuracy: 0.9876\nEpoch 76/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.2903 - accuracy: 0.9706 - val_loss: 0.4271 - val_accuracy: 0.9844\nEpoch 77/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.2597 - accuracy: 0.9718 - val_loss: 0.3661 - val_accuracy: 0.9866\nEpoch 78/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.2041 - accuracy: 0.9781 - val_loss: 0.3465 - val_accuracy: 0.9878\nEpoch 79/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.2196 - accuracy: 0.9775 - val_loss: 0.3330 - val_accuracy: 0.9872\nEpoch 80/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.2087 - accuracy: 0.9796 - val_loss: 0.3729 - val_accuracy: 0.9871\nEpoch 81/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.2846 - accuracy: 0.9729 - val_loss: 0.3154 - val_accuracy: 0.9885\nEpoch 82/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.2392 - accuracy: 0.9750 - val_loss: 0.3742 - val_accuracy: 0.9874\nEpoch 83/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.2632 - accuracy: 0.9754 - val_loss: 0.5013 - val_accuracy: 0.9821\nEpoch 84/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.2485 - accuracy: 0.9729 - val_loss: 0.3866 - val_accuracy: 0.9877\nEpoch 85/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.2645 - accuracy: 0.9762 - val_loss: 0.4354 - val_accuracy: 0.9839\nEpoch 86/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.2096 - accuracy: 0.9787 - val_loss: 0.3383 - val_accuracy: 0.9884\nEpoch 87/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.2069 - accuracy: 0.9792 - val_loss: 0.3573 - val_accuracy: 0.9871\nEpoch 88/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.2109 - accuracy: 0.9795 - val_loss: 0.3832 - val_accuracy: 0.9859\nEpoch 89/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.2769 - accuracy: 0.9735 - val_loss: 0.3723 - val_accuracy: 0.9867\nEpoch 90/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.2079 - accuracy: 0.9780 - val_loss: 0.3602 - val_accuracy: 0.9866\nEpoch 91/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1975 - accuracy: 0.9791 - val_loss: 0.3202 - val_accuracy: 0.9888\nEpoch 92/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1855 - accuracy: 0.9799 - val_loss: 0.3321 - val_accuracy: 0.9883\nEpoch 93/250\n89/89 [==============================] - 5s 58ms/step - loss: 0.2185 - accuracy: 0.9795 - val_loss: 0.3847 - val_accuracy: 0.9866\nEpoch 94/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.2049 - accuracy: 0.9811 - val_loss: 0.3441 - val_accuracy: 0.9878\nEpoch 95/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.2484 - accuracy: 0.9749 - val_loss: 0.3650 - val_accuracy: 0.9865\nEpoch 96/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.1996 - accuracy: 0.9802 - val_loss: 0.3495 - val_accuracy: 0.9887\nEpoch 97/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.2214 - accuracy: 0.9736 - val_loss: 0.3565 - val_accuracy: 0.9877\nEpoch 98/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.2052 - accuracy: 0.9776 - val_loss: 0.3490 - val_accuracy: 0.9872\nEpoch 99/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1788 - accuracy: 0.9813 - val_loss: 0.3666 - val_accuracy: 0.9866\nEpoch 100/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1816 - accuracy: 0.9834 - val_loss: 0.3981 - val_accuracy: 0.9854\nEpoch 101/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.2064 - accuracy: 0.9813 - val_loss: 0.3611 - val_accuracy: 0.9876\nEpoch 102/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.2228 - accuracy: 0.9779 - val_loss: 0.3236 - val_accuracy: 0.9900\nEpoch 103/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1828 - accuracy: 0.9825 - val_loss: 0.4330 - val_accuracy: 0.9841\nEpoch 104/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1629 - accuracy: 0.9853 - val_loss: 0.3150 - val_accuracy: 0.9901\nEpoch 105/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1475 - accuracy: 0.9848 - val_loss: 0.3361 - val_accuracy: 0.9885\nEpoch 106/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.1680 - accuracy: 0.9825 - val_loss: 0.3687 - val_accuracy: 0.9859\nEpoch 107/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1982 - accuracy: 0.9828 - val_loss: 0.3842 - val_accuracy: 0.9878\nEpoch 108/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1838 - accuracy: 0.9811 - val_loss: 0.3305 - val_accuracy: 0.9885\nEpoch 109/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1750 - accuracy: 0.9829 - val_loss: 0.2803 - val_accuracy: 0.9911\nEpoch 110/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.1829 - accuracy: 0.9822 - val_loss: 0.3868 - val_accuracy: 0.9878\nEpoch 111/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1719 - accuracy: 0.9848 - val_loss: 0.3148 - val_accuracy: 0.9898\nEpoch 112/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1763 - accuracy: 0.9836 - val_loss: 0.3589 - val_accuracy: 0.9858\nEpoch 113/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.2211 - accuracy: 0.9789 - val_loss: 0.3959 - val_accuracy: 0.9861\nEpoch 114/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1990 - accuracy: 0.9824 - val_loss: 0.3371 - val_accuracy: 0.9876\nEpoch 115/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.2026 - accuracy: 0.9812 - val_loss: 0.3316 - val_accuracy: 0.9888\nEpoch 116/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1716 - accuracy: 0.9834 - val_loss: 0.3368 - val_accuracy: 0.9894\nEpoch 117/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1766 - accuracy: 0.9839 - val_loss: 0.3611 - val_accuracy: 0.9886\nEpoch 118/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1568 - accuracy: 0.9856 - val_loss: 0.3602 - val_accuracy: 0.9879\nEpoch 119/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1860 - accuracy: 0.9838 - val_loss: 0.3382 - val_accuracy: 0.9890\nEpoch 120/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.2113 - accuracy: 0.9806 - val_loss: 0.3224 - val_accuracy: 0.9890\nEpoch 121/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1940 - accuracy: 0.9826 - val_loss: 0.3376 - val_accuracy: 0.9896\nEpoch 122/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1710 - accuracy: 0.9843 - val_loss: 0.2873 - val_accuracy: 0.9906\nEpoch 123/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1313 - accuracy: 0.9872 - val_loss: 0.3429 - val_accuracy: 0.9884\nEpoch 124/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1988 - accuracy: 0.9816 - val_loss: 0.3349 - val_accuracy: 0.9888\nEpoch 125/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1554 - accuracy: 0.9855 - val_loss: 0.3571 - val_accuracy: 0.9893\nEpoch 126/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.1776 - accuracy: 0.9839 - val_loss: 0.3580 - val_accuracy: 0.9888\nEpoch 127/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1659 - accuracy: 0.9838 - val_loss: 0.4764 - val_accuracy: 0.9837\nEpoch 128/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1956 - accuracy: 0.9856 - val_loss: 0.3048 - val_accuracy: 0.9907\nEpoch 129/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1505 - accuracy: 0.9858 - val_loss: 0.3318 - val_accuracy: 0.9890\nEpoch 130/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1535 - accuracy: 0.9865 - val_loss: 0.5200 - val_accuracy: 0.9817\nEpoch 131/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.2151 - accuracy: 0.9825 - val_loss: 0.3823 - val_accuracy: 0.9856\nEpoch 132/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1767 - accuracy: 0.9832 - val_loss: 0.3211 - val_accuracy: 0.9885\nEpoch 133/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1481 - accuracy: 0.9853 - val_loss: 0.3910 - val_accuracy: 0.9870\nEpoch 134/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1746 - accuracy: 0.9854 - val_loss: 0.3160 - val_accuracy: 0.9901\nEpoch 135/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1687 - accuracy: 0.9840 - val_loss: 0.3376 - val_accuracy: 0.9888\nEpoch 136/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1777 - accuracy: 0.9867 - val_loss: 0.3158 - val_accuracy: 0.9892\nEpoch 137/250\n89/89 [==============================] - 5s 58ms/step - loss: 0.1852 - accuracy: 0.9840 - val_loss: 0.4407 - val_accuracy: 0.9833\nEpoch 138/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1813 - accuracy: 0.9850 - val_loss: 0.3543 - val_accuracy: 0.9896\nEpoch 139/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1252 - accuracy: 0.9877 - val_loss: 0.3120 - val_accuracy: 0.9904\nEpoch 140/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1816 - accuracy: 0.9836 - val_loss: 0.3183 - val_accuracy: 0.9896\nEpoch 141/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1673 - accuracy: 0.9861 - val_loss: 0.3310 - val_accuracy: 0.9897\nEpoch 142/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1911 - accuracy: 0.9803 - val_loss: 0.3192 - val_accuracy: 0.9898\nEpoch 143/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1319 - accuracy: 0.9877 - val_loss: 0.2782 - val_accuracy: 0.9912\nEpoch 144/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1250 - accuracy: 0.9907 - val_loss: 0.3058 - val_accuracy: 0.9904\nEpoch 145/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1881 - accuracy: 0.9854 - val_loss: 0.3173 - val_accuracy: 0.9896\nEpoch 146/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1383 - accuracy: 0.9867 - val_loss: 0.3434 - val_accuracy: 0.9879\nEpoch 147/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.1930 - accuracy: 0.9837 - val_loss: 0.3132 - val_accuracy: 0.9889\nEpoch 148/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1184 - accuracy: 0.9889 - val_loss: 0.3364 - val_accuracy: 0.9888\nEpoch 149/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.1815 - accuracy: 0.9855 - val_loss: 0.3658 - val_accuracy: 0.9869\nEpoch 150/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1648 - accuracy: 0.9870 - val_loss: 0.3392 - val_accuracy: 0.9885\nEpoch 151/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.1366 - accuracy: 0.9864 - val_loss: 0.2715 - val_accuracy: 0.9911\nEpoch 152/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1436 - accuracy: 0.9861 - val_loss: 0.2782 - val_accuracy: 0.9920\nEpoch 153/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1572 - accuracy: 0.9858 - val_loss: 0.3086 - val_accuracy: 0.9901\nEpoch 154/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1368 - accuracy: 0.9878 - val_loss: 0.2827 - val_accuracy: 0.9915\nEpoch 155/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1530 - accuracy: 0.9878 - val_loss: 0.3712 - val_accuracy: 0.9871\nEpoch 156/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.1234 - accuracy: 0.9888 - val_loss: 0.3178 - val_accuracy: 0.9894\nEpoch 157/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1326 - accuracy: 0.9890 - val_loss: 0.3426 - val_accuracy: 0.9885\nEpoch 158/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1731 - accuracy: 0.9836 - val_loss: 0.3703 - val_accuracy: 0.9859\nEpoch 159/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1960 - accuracy: 0.9839 - val_loss: 0.3132 - val_accuracy: 0.9903\nEpoch 160/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1462 - accuracy: 0.9883 - val_loss: 0.4482 - val_accuracy: 0.9846\nEpoch 161/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1776 - accuracy: 0.9864 - val_loss: 0.3421 - val_accuracy: 0.9889\nEpoch 162/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1471 - accuracy: 0.9862 - val_loss: 0.2815 - val_accuracy: 0.9913\nEpoch 163/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1275 - accuracy: 0.9899 - val_loss: 0.3438 - val_accuracy: 0.9894\nEpoch 164/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1719 - accuracy: 0.9841 - val_loss: 0.3070 - val_accuracy: 0.9890\nEpoch 165/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1338 - accuracy: 0.9873 - val_loss: 0.3041 - val_accuracy: 0.9902\nEpoch 166/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1580 - accuracy: 0.9868 - val_loss: 0.3509 - val_accuracy: 0.9889\nEpoch 167/250\n89/89 [==============================] - 5s 53ms/step - loss: 0.1636 - accuracy: 0.9851 - val_loss: 0.2765 - val_accuracy: 0.9915\nEpoch 168/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1430 - accuracy: 0.9862 - val_loss: 0.2988 - val_accuracy: 0.9895\nEpoch 169/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.1438 - accuracy: 0.9880 - val_loss: 0.2915 - val_accuracy: 0.9903\nEpoch 170/250\n89/89 [==============================] - 4s 50ms/step - loss: 0.1397 - accuracy: 0.9869 - val_loss: 0.2696 - val_accuracy: 0.9913\nEpoch 171/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1160 - accuracy: 0.9896 - val_loss: 0.4026 - val_accuracy: 0.9860\nEpoch 172/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1666 - accuracy: 0.9856 - val_loss: 0.3099 - val_accuracy: 0.9900\nEpoch 173/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1488 - accuracy: 0.9874 - val_loss: 0.2880 - val_accuracy: 0.9911\nEpoch 174/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1333 - accuracy: 0.9908 - val_loss: 0.2631 - val_accuracy: 0.9909\nEpoch 175/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1344 - accuracy: 0.9883 - val_loss: 0.3167 - val_accuracy: 0.9896\nEpoch 176/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1277 - accuracy: 0.9887 - val_loss: 0.3151 - val_accuracy: 0.9899\nEpoch 177/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1299 - accuracy: 0.9879 - val_loss: 0.2890 - val_accuracy: 0.9901\nEpoch 178/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1659 - accuracy: 0.9875 - val_loss: 0.3147 - val_accuracy: 0.9901\nEpoch 179/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1430 - accuracy: 0.9884 - val_loss: 0.2475 - val_accuracy: 0.9921\nEpoch 180/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1243 - accuracy: 0.9873 - val_loss: 0.3239 - val_accuracy: 0.9898\nEpoch 181/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1277 - accuracy: 0.9901 - val_loss: 0.3667 - val_accuracy: 0.9880\nEpoch 182/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1555 - accuracy: 0.9888 - val_loss: 0.2705 - val_accuracy: 0.9912\nEpoch 183/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1085 - accuracy: 0.9913 - val_loss: 0.2794 - val_accuracy: 0.9914\nEpoch 184/250\n89/89 [==============================] - 5s 53ms/step - loss: 0.1282 - accuracy: 0.9899 - val_loss: 0.3019 - val_accuracy: 0.9903\nEpoch 185/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1192 - accuracy: 0.9914 - val_loss: 0.3534 - val_accuracy: 0.9882\nEpoch 186/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1574 - accuracy: 0.9881 - val_loss: 0.2706 - val_accuracy: 0.9909\nEpoch 187/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1249 - accuracy: 0.9893 - val_loss: 0.3989 - val_accuracy: 0.9842\nEpoch 188/250\n89/89 [==============================] - 5s 59ms/step - loss: 0.1662 - accuracy: 0.9865 - val_loss: 0.2938 - val_accuracy: 0.9901\nEpoch 189/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1620 - accuracy: 0.9865 - val_loss: 0.3088 - val_accuracy: 0.9896\nEpoch 190/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1680 - accuracy: 0.9871 - val_loss: 0.3828 - val_accuracy: 0.9873\nEpoch 191/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1466 - accuracy: 0.9848 - val_loss: 0.3721 - val_accuracy: 0.9879\nEpoch 192/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1262 - accuracy: 0.9900 - val_loss: 0.3773 - val_accuracy: 0.9886\nEpoch 193/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1346 - accuracy: 0.9888 - val_loss: 0.3198 - val_accuracy: 0.9905\nEpoch 194/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1156 - accuracy: 0.9909 - val_loss: 0.3455 - val_accuracy: 0.9888\nEpoch 195/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1570 - accuracy: 0.9880 - val_loss: 0.3061 - val_accuracy: 0.9912\nEpoch 196/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1119 - accuracy: 0.9924 - val_loss: 0.4090 - val_accuracy: 0.9854\nEpoch 197/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1436 - accuracy: 0.9871 - val_loss: 0.3469 - val_accuracy: 0.9876\nEpoch 198/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1316 - accuracy: 0.9904 - val_loss: 0.3700 - val_accuracy: 0.9877\nEpoch 199/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1517 - accuracy: 0.9890 - val_loss: 0.3593 - val_accuracy: 0.9881\nEpoch 200/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1311 - accuracy: 0.9890 - val_loss: 0.2953 - val_accuracy: 0.9895\nEpoch 201/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1514 - accuracy: 0.9878 - val_loss: 0.2848 - val_accuracy: 0.9913\nEpoch 202/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1364 - accuracy: 0.9890 - val_loss: 0.3129 - val_accuracy: 0.9901\nEpoch 203/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1440 - accuracy: 0.9874 - val_loss: 0.3108 - val_accuracy: 0.9891\nEpoch 204/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1384 - accuracy: 0.9914 - val_loss: 0.3075 - val_accuracy: 0.9900\nEpoch 205/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1793 - accuracy: 0.9875 - val_loss: 0.2993 - val_accuracy: 0.9903\nEpoch 206/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.0998 - accuracy: 0.9924 - val_loss: 0.3347 - val_accuracy: 0.9880\nEpoch 207/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1264 - accuracy: 0.9907 - val_loss: 0.3076 - val_accuracy: 0.9905\nEpoch 208/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1390 - accuracy: 0.9894 - val_loss: 0.2955 - val_accuracy: 0.9908\nEpoch 209/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1272 - accuracy: 0.9898 - val_loss: 0.2894 - val_accuracy: 0.9902\nEpoch 210/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1277 - accuracy: 0.9887 - val_loss: 0.3346 - val_accuracy: 0.9896\nEpoch 211/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1406 - accuracy: 0.9894 - val_loss: 0.3403 - val_accuracy: 0.9892\nEpoch 212/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1571 - accuracy: 0.9877 - val_loss: 0.3350 - val_accuracy: 0.9900\nEpoch 213/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1252 - accuracy: 0.9899 - val_loss: 0.3254 - val_accuracy: 0.9896\nEpoch 214/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1311 - accuracy: 0.9870 - val_loss: 0.2782 - val_accuracy: 0.9913\nEpoch 215/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1283 - accuracy: 0.9900 - val_loss: 0.2779 - val_accuracy: 0.9905\nEpoch 216/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1115 - accuracy: 0.9912 - val_loss: 0.2797 - val_accuracy: 0.9920\nEpoch 217/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1140 - accuracy: 0.9900 - val_loss: 0.2958 - val_accuracy: 0.9904\nEpoch 218/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1328 - accuracy: 0.9903 - val_loss: 0.3252 - val_accuracy: 0.9897\nEpoch 219/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1375 - accuracy: 0.9891 - val_loss: 0.3013 - val_accuracy: 0.9904\nEpoch 220/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1574 - accuracy: 0.9887 - val_loss: 0.2793 - val_accuracy: 0.9913\nEpoch 221/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1181 - accuracy: 0.9902 - val_loss: 0.3503 - val_accuracy: 0.9874\nEpoch 222/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1252 - accuracy: 0.9891 - val_loss: 0.3245 - val_accuracy: 0.9896\nEpoch 223/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1786 - accuracy: 0.9881 - val_loss: 0.3656 - val_accuracy: 0.9874\nEpoch 224/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1380 - accuracy: 0.9889 - val_loss: 0.3176 - val_accuracy: 0.9896\nEpoch 225/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1612 - accuracy: 0.9879 - val_loss: 0.2671 - val_accuracy: 0.9911\nEpoch 226/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1389 - accuracy: 0.9900 - val_loss: 0.3337 - val_accuracy: 0.9892\nEpoch 227/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1261 - accuracy: 0.9907 - val_loss: 0.3011 - val_accuracy: 0.9917\nEpoch 228/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1398 - accuracy: 0.9896 - val_loss: 0.3204 - val_accuracy: 0.9893\nEpoch 229/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1287 - accuracy: 0.9909 - val_loss: 0.3081 - val_accuracy: 0.9902\nEpoch 230/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1319 - accuracy: 0.9895 - val_loss: 0.2979 - val_accuracy: 0.9910\nEpoch 231/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1584 - accuracy: 0.9900 - val_loss: 0.2918 - val_accuracy: 0.9908\nEpoch 232/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1308 - accuracy: 0.9887 - val_loss: 0.3279 - val_accuracy: 0.9892\nEpoch 233/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1121 - accuracy: 0.9905 - val_loss: 0.2830 - val_accuracy: 0.9904\nEpoch 234/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1221 - accuracy: 0.9908 - val_loss: 0.3081 - val_accuracy: 0.9902\nEpoch 235/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1347 - accuracy: 0.9879 - val_loss: 0.3307 - val_accuracy: 0.9897\nEpoch 236/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1537 - accuracy: 0.9900 - val_loss: 0.2556 - val_accuracy: 0.9925\nEpoch 237/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1150 - accuracy: 0.9907 - val_loss: 0.2328 - val_accuracy: 0.9927\nEpoch 238/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1418 - accuracy: 0.9910 - val_loss: 0.3276 - val_accuracy: 0.9893\nEpoch 239/250\n89/89 [==============================] - 5s 58ms/step - loss: 0.1270 - accuracy: 0.9913 - val_loss: 0.2886 - val_accuracy: 0.9915\nEpoch 240/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1165 - accuracy: 0.9905 - val_loss: 0.3209 - val_accuracy: 0.9904\nEpoch 241/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1412 - accuracy: 0.9889 - val_loss: 0.2602 - val_accuracy: 0.9921\nEpoch 242/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1175 - accuracy: 0.9902 - val_loss: 0.2754 - val_accuracy: 0.9916\nEpoch 243/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1068 - accuracy: 0.9921 - val_loss: 0.2579 - val_accuracy: 0.9928\nEpoch 244/250\n89/89 [==============================] - 4s 51ms/step - loss: 0.1007 - accuracy: 0.9925 - val_loss: 0.2635 - val_accuracy: 0.9921\nEpoch 245/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1111 - accuracy: 0.9923 - val_loss: 0.3117 - val_accuracy: 0.9898\nEpoch 246/250\n89/89 [==============================] - 5s 52ms/step - loss: 0.1615 - accuracy: 0.9884 - val_loss: 0.3580 - val_accuracy: 0.9875\nEpoch 247/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1174 - accuracy: 0.9914 - val_loss: 0.2854 - val_accuracy: 0.9911\nEpoch 248/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1129 - accuracy: 0.9912 - val_loss: 0.2923 - val_accuracy: 0.9908\nEpoch 249/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1036 - accuracy: 0.9907 - val_loss: 0.2813 - val_accuracy: 0.9915\nEpoch 250/250\n89/89 [==============================] - 5s 51ms/step - loss: 0.1188 - accuracy: 0.9918 - val_loss: 0.2463 - val_accuracy: 0.9927\n","output_type":"stream"}]},{"cell_type":"code","source":"####### Phase-2 Model \n\n###### With Dense\nwith tpu_strategy.scope():\n\n    ##### SC-Net based Model \n    SC_model = tf.keras.models.Model(inputs=model.input,outputs=model.layers[-7].output) # Taking output of SC-Net from Conv6 (-7 for with Dense and -5 for without )\n    SC_model.compile(tf.keras.optimizers.Adam(lr=1e-4),loss='categorical_crossentropy',metrics=['accuracy'])\n    SC_model.trainable = False # Freezing the Trainable Model\n    \nwith tpu_strategy.scope():\n    \n    #### Defining Hyperparameters\n    num_layers = 2\n    d_model = 512\n    num_heads = 8\n    dff = 1024\n    max_seq_len = 1280 #X_train.shape[1]\n    pe_input = max_seq_len\n    rate = 0.5\n    num_features = 1\n    num_classes = 47\n    \n    ##### SC-Net+Transformer Model\n    y_in = tf.keras.layers.Input((47,))\n    Input_Layer = tf.keras.layers.Input((1280,1))\n    op_1 = SC_model([Input_Layer,y_in])\n\n    #### Narrow-Head Attention Transformer Model\n    #mask_reshaped = tf.keras.layers.Reshape((max_seq_len,))(Input_Layer)\n    embeddings = transformer(inp=op_1,enc_padding_mask=None)\n    #residual_embeddings = tf.keras.layers.Add()([conv6,embeddings])\n    \n    #### Output Network\n    ## Initial Layers\n    gap_op = gap_layer(embeddings)\n    dense1 = tf.keras.layers.Dense(256,activation='relu')(gap_op)\n    dropout1 = tf.keras.layers.Dropout(rate)(dense1)\n    \n    ### ArcFace Output Network\n    dense2 = tf.keras.layers.Dense(256,kernel_initializer='he_normal',\n                kernel_regularizer=tf.keras.regularizers.l2(1e-4))(dropout1)\n    ##dense2 = tf.keras.layers.BatchNormalization()(dense2)\n    dense3 = arc_logit_layer(([dense2,y_in]))\n\n    #### Compiling Architecture            \n    ### ArcFace Model Compilation\n    model_transformer = tf.keras.models.Model(inputs=[Input_Layer,y_in],outputs=dense3)\n    ### Softmax Model Compilation\n    #model = tf.keras.models.Model(inputs=Inputs,outputs=dense3)\n    model_transformer.load_weights('./Transfomer_with_Dense_TPTP_MITBIH.h5')\n    model_transformer.compile(tf.keras.optimizers.Adam(lr=1e-4,clipnorm=1.0),loss='categorical_crossentropy',metrics=['accuracy'])\n\nmodel_transformer.summary()      \ntf.keras.utils.plot_model(model_transformer)\n##### Model Training \n\n#### Model Checkpointing\nfilepath = './Transfomer_with_Dense_TPTP_MITBIH.h5'\ncheckpoint = tf.keras.callbacks.ModelCheckpoint(filepath,monitor='val_accuracy',save_best_only=True,mode='max',save_weights_only=True)\n\n#### Model Training\n#### Model Training\n### ArcFace Training\n#history = model_transformer.fit((X_train,y_train_ohot),y_train_ohot,epochs=250,batch_size=128,\n#                validation_data=((X_dev,y_dev_ohot),y_dev_ohot),validation_batch_size=128,\n#               callbacks=checkpoint)\n\n### Softmax Training \n#history = model.fit(X_train,y_train_ohot,epochs=250,batch_size=128,\n#                validation_data=(X_dev,y_dev_ohot),validation_batch_size=128,\n#                callbacks=checkpoint)\n\n##### Plotting Metrics  \n#### Accuracy and Loss Plots \n\n### Accuracy\n#plt.plot(history.history['accuracy'])\n#plt.plot(history.history['val_accuracy'])\n#plt.title('Model Accuracy')\n#plt.ylabel('Accuracy')  \n#plt.xlabel('Epoch')  \n#plt.legend(['Train', 'Validation'], loc='best')\n#plt.show()\n\n### Loss     \n#plt.plot(history.history['loss'])  \n#plt.plot(history.history['val_loss'])\n#plt.title('Model Loss')  \n#plt.ylabel('Loss')         \n#plt.xlabel('epoch')\n#plt.legend(['Train', 'Validation'], loc='best')   \n#plt.show()","metadata":{"execution":{"iopub.status.busy":"2021-05-29T16:37:37.224145Z","iopub.execute_input":"2021-05-29T16:37:37.224536Z","iopub.status.idle":"2021-05-29T16:37:39.718136Z","shell.execute_reply.started":"2021-05-29T16:37:37.224503Z","shell.execute_reply":"2021-05-29T16:37:39.716631Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"##### Histogram Plot                             \nweights_init = np.array(model.get_weights())     \nweights_init.flatten()\n\nweights_final = []       \n\nfor i in range(101):\n    for item in weights_init[i].flatten():\n        weights_final.append(item)\n    \n#weights_before_train = np.array(weights_final)\n#print(weights_before_train.shape)   \n    \nweights_after_train = np.array(weights_final)\nprint(weights_after_train.shape)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"weight_main = np.absolute(weights_after_train) #-weights_before_train)\nprint(weight_main.shape)\nfor item in [10]:\n    plt.hist(weight_main,bins=int(item))\n    item_path = 'hist_plot_'+str(item)+'.png'\n    plt.savefig(item_path)\n    plt.show()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Model Testing","metadata":{}},{"cell_type":"markdown","source":"## KNN Testing based on ArcFace Loss","metadata":{}},{"cell_type":"code","source":"###### Testing Model - ArcFace Style\nwith tpu_strategy.scope():\n\n    def normalisation_layer(x):   \n        return(tf.math.l2_normalize(x, axis=1, epsilon=1e-12))\n\n    #X_dev_flipped = tf.image.flip_up_down(X_dev)  \n    #x_train_flipped = tf.image.flip_up_down(X_train_final)\n\n    predictive_model = tf.keras.models.Model(inputs=model.input,outputs=model.layers[-3].output)\n    predictive_model.compile(tf.keras.optimizers.Adam(lr=1e-4),loss='categorical_crossentropy',metrics=['accuracy'])\n\nwith tpu_strategy.scope():\n    y_in = tf.keras.layers.Input((47,))\n\n    Input_Layer = tf.keras.layers.Input((1280,1))\n    op_1 = predictive_model([Input_Layer,y_in])\n\n    ##Input_Layer_Flipped = tf.keras.layers.Input((224,224,3))\n    ##op_2 = predictive_model([Input_Layer_Flipped,y_in]) \n    ##final_op = tf.keras.layers.Concatenate(axis=1)(op_1)\n\n    final_norm_op = tf.keras.layers.Lambda(normalisation_layer)(op_1)\n\n    testing_model = tf.keras.models.Model(inputs=[Input_Layer,y_in],outputs=final_norm_op)\n    testing_model.compile(tf.keras.optimizers.Adam(lr=1e-4),loss='categorical_crossentropy',metrics=['accuracy'])\n\n##### Nearest Neighbor Classification\nfrom sklearn.neighbors import KNeighborsClassifier\nTest_Embeddings = testing_model.predict((X_dev,y_dev_ohot))\nTrain_Embeddings = testing_model.predict((X_train,y_train_ohot))\n\ncol_mean = np.nanmean(Test_Embeddings, axis=0)\ninds = np.where(np.isnan(Test_Embeddings))\nTest_Embeddings[inds] = np.take(col_mean, inds[1])\n\ncol_mean = np.nanmean(Train_Embeddings, axis=0)\ninds = np.where(np.isnan(Train_Embeddings))\nTrain_Embeddings[inds] = np.take(col_mean, inds[1])\n\n#Test_Embeddings = np.nan_to_num(Test_Embeddings)\n\n##### Refining Test Embeddings\n#for i in range(Train_Embeddings.shape[0]):\n#    for j in range(Train_Embeddings.shape[1]):\n#        if(math.isnan(Train_Embeddings[i,j])):\n#            Train_Embeddings[i,j] == 0\n#        if(Train_Embeddings[i,j]>1e4):\n#            Train_Embeddings[i,j] == 1e4\n\n##### Refining Train Embeddings    \n#for i in range(Test_Embeddings.shape[0]):\n#    for j in range(Test_Embeddings.shape[1]):\n#        if(math.isnan(Test_Embeddings[i,j])):\n#            Test_Embeddings[i,j] == 0\n#        if(Test_Embeddings[i,j]>1e4 or math.isinf(Test_Embeddings[i,j])):\n#            Test_Embeddings[i,j] == 1e4\n\n#del(X_train_final,X_dev,X_dev_flipped,x_train_flipped)\n#gc.collect()\n\nTest_Accuracy_With_Train = []\nTest_Accuracy_With_Test = []\n                                                                     \nfor k in range(1,11):\n    knn = KNeighborsClassifier(n_neighbors=k,metric='euclidean')\n    knn.fit(Train_Embeddings,y_train)\n    Test_Accuracy_With_Train.append(knn.score(Test_Embeddings,y_dev))\n    knn.fit(Test_Embeddings,y_dev)\n    Test_Accuracy_With_Test.append(knn.score(Test_Embeddings,y_dev))\n\nprint(np.max(Test_Accuracy_With_Train))\nprint(np.max(Test_Accuracy_With_Test))\nprint(np.mean(Test_Accuracy_With_Train))\nprint(np.mean(Test_Accuracy_With_Test))\n\nplt.plot(np.arange(1,11),np.array(Test_Accuracy_With_Train),label='Test_Accuracy_With_Train')\nplt.plot(np.arange(1,11),np.array(Test_Accuracy_With_Test),label='Test_Accuracy_With_Test')\nplt.title('Testing Accuracy vs Number of Neighbors')\nplt.xlabel('Number of Neighbors')\nplt.ylabel('Test Accuracy')\nplt.legend()       \nplt.show()  ","metadata":{"execution":{"iopub.status.busy":"2021-06-01T06:05:20.989352Z","iopub.execute_input":"2021-06-01T06:05:20.989746Z","iopub.status.idle":"2021-06-01T06:06:56.503182Z","shell.execute_reply.started":"2021-06-01T06:05:20.989706Z","shell.execute_reply":"2021-06-01T06:06:56.502337Z"},"trusted":true},"execution_count":16,"outputs":[{"name":"stdout","text":"0.994821890902598\n1.0\n0.9945986965449514\n0.9959289349165253\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"code","source":"###### Testing Model - Softmax Style Model\n\nwith tpu_strategy.scope():\n\n    def normalisation_layer(x):\n        return(tf.math.l2_normalize(x, axis=1, epsilon=1e-12))\n\n    #X_dev_flipped = tf.image.flip_up_down(X_dev)\n    #x_train_flipped = tf.image.flip_up_down(X_train_final)\n\n    predictive_model = tf.keras.models.Model(inputs=model.input,outputs=model.layers[-2].output)\n    predictive_model.compile(tf.keras.optimizers.Adam(lr=1e-4),loss='categorical_crossentropy',metrics=['accuracy'])\n\n    #y_in = tf.keras.layers.Input((24,))\n\n    Input_Layer = tf.keras.layers.Input((1280,1))\n    op_1 = predictive_model(Input_Layer)\n      \n    ##Input_Layer_Flipped = tf.keras.layers.Input((224,224,3))\n    ##op_2 = predictive_model([Input_Layer_Flipped,y_in]) \n    ##final_op = tf.keras.layers.Concatenate(axis=1)(op_1)\n\n    final_norm_op = tf.keras.layers.Lambda(normalisation_layer)(op_1)\n\n    testing_model = tf.keras.models.Model(inputs=Input_Layer,outputs=op_1)\n    testing_model.compile(tf.keras.optimizers.Adam(lr=1e-4),loss='categorical_crossentropy',metrics=['accuracy'])\n\n##### Nearest Neighbor Classification\nfrom sklearn.neighbors import KNeighborsClassifier\nTest_Embeddings = testing_model.predict((X_dev,y_dev_ohot))\nTrain_Embeddings = testing_model.predict((X_train,y_train_ohot))\n\nTest_Accuracy_With_Train = []\nTest_Accuracy_With_Test = []\n                                                                     \nfor k in range(1,26):\n    knn = KNeighborsClassifier(n_neighbors=k,metric='euclidean')\n    knn.fit(Train_Embeddings,y_train)\n    Test_Accuracy_With_Train.append(knn.score(Test_Embeddings,y_dev))\n    knn.fit(Test_Embeddings,y_dev)\n    Test_Accuracy_With_Test.append(knn.score(Test_Embeddings,y_dev))\n\nprint(np.max(Test_Accuracy_With_Train))\nprint(np.max(Test_Accuracy_With_Test))\nprint(np.mean(Test_Accuracy_With_Train))\nprint(np.mean(Test_Accuracy_With_Test))\n\nplt.plot(np.arange(1,26),np.array(Test_Accuracy_With_Train),label='Test_Accuracy_With_Train')\nplt.plot(np.arange(1,26),np.array(Test_Accuracy_With_Test),label='Test_Accuracy_With_Test')\nplt.title('Testing Accuracy vs Number of Neighbors')\nplt.xlabel('Number of Neighbors')\nplt.ylabel('Test Accuracy')\nplt.legend()       \nplt.show()  ","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## t-SNE Plots","metadata":{}},{"cell_type":"code","source":"####### t-SNE Plot Generation\n###### Model Creation\n#with tpu_strategy.scope():          \n#    tsne_model = tf.keras.models.Model(inputs=model.input,outputs=model.layers[-4].output)\n#    tsne_model.compile(tf.keras.optimizers.Adam(lr=1e-4),loss='categorical_crossentropy',metrics=['accuracy'])\n#tsne_model.summary()\n\n###### Model Predicted\n#embeddings_final = tsne_model.predict((X_dev,y_exp))\n\n###### t-SNE plot plotting\n##### Reduction to Lower Dimensions\ntsne_X_dev = TSNE(n_components=2,perplexity=30,learning_rate=10,n_iter=2000,n_iter_without_progress=50).fit_transform(Test_Embeddings)\n\n##### Plotting\nj = 0 # Index for rotating legend\nplt.rcParams[\"figure.figsize\"] = [18,14]\nmStyles = [\".\",\",\",\"o\",\"v\",\"^\",\"<\",\">\",\"1\",\"2\",\"3\",\"4\",\"8\",\"s\",\"p\",\"P\",\"*\",\"h\",\"H\",\"+\",\"x\",\"X\",\"D\",\"d\",\"|\",\"_\",0,1,2,3,4,5,6,7,8,9,10,11,0,1,2,3,4,5,6,7,8,9,10]\nfor idx,color_index,marker_type in zip(list(np.arange(47)),sns.color_palette('muted',47),mStyles):\n    plt.scatter(tsne_X_dev[y_dev == idx, 0], tsne_X_dev[y_dev == idx, 1],marker=marker_type)\nplt.legend([str(j) for j in range(47)])\nplt.savefig('tsne_plot_5000_iters.png')\nplt.savefig('tsne_plot_5000_iters.pdf')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2021-06-01T06:06:56.505310Z","iopub.execute_input":"2021-06-01T06:06:56.505907Z","iopub.status.idle":"2021-06-01T06:08:56.278414Z","shell.execute_reply.started":"2021-06-01T06:06:56.505861Z","shell.execute_reply":"2021-06-01T06:08:56.277298Z"},"trusted":true},"execution_count":17,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1296x1008 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","source":"# Matching","metadata":{}},{"cell_type":"markdown","source":"## Single Beat","metadata":{}},{"cell_type":"code","source":"####### Matching     \n                                                  \n###### Matching File Generartion\n\n##### Data Arrangment                                                                        \n! mkdir './Single_Beat_Ecg_MITBIH_Matching' # Generating major database of datasets\ncurrent_index = 1\n\nmit_dbs_path = '../input/mitbih-database'\nfor i in range(0,96,2): # Loop over all the files\n    rec_file_path = os.path.join(mit_dbs_path,str(np.sort(os.listdir(mit_dbs_path))[i])) # Path Selection\n    attr_file_path = os.path.join(mit_dbs_path,str(np.sort(os.listdir(mit_dbs_path))[i+1])) # Path Selction\n    \n    signal_current = data_read_mit(rec_file_path) # Current ECG Signal\n    r_peaks_current = feature_extractor(attr_file_path) # R-peaks\n    seg_signal_current,new_r_peaks = (segmentSignals(signal_current,list(r_peaks_current))) # Segmented ECG Signals\n    seg_signal_current = np.array(seg_signal_current)_experiment\n    \n    ##### Creation of Person's Folder\n    current_storage_path = './Single_Beat_Ecg_MITBIH_Matching'+'/person'+str(current_index)\n    Path(current_storage_path).mkdir(parents=True, exist_ok=True)\n\n    ##### Creation of Probe and Gallery Subdirectories\n    #### Gallery(Training Set)\n    gallery_path = current_storage_path+'/Gallery'\n    Path(gallery_path).mkdir(parents=True, exist_ok=True)\n\n    #### Probe(Testing Set)\n    probe_path = current_storage_path+'/Probe'\n    Path(probe_path).mkdir(parents=True, exist_ok=True)\n\n    #### Populating Subdirectories\n    for j in range(seg_signal_current.shape[0]):\n\n        if(j%2 == 0):\n            current_output = tsne_model.predict(np.reshape(seg_signal_current[j],(1,256,1)))\n            file_name_current = gallery_path+'/'+str(j)\n            np.savez_compressed(file_name_current,current_output)\n        else:\n            current_output = tsne_model.predict(np.reshape(seg_signal_current[j],(1,256,1)))\n            file_name_current = probe_path+'/'+str(j)\n            np.savez_compressed(file_name_current,current_output)\n\n    current_index = current_index+1","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## 5 Beat Matching","metadata":{}},{"cell_type":"code","source":"###### Extracting Embeddings\n\n##### Model Formation\n\n#### Softmax Model\n#with tpu_strategy.scope():      \ntsne_model = tf.keras.models.Model(inputs=model.input,outputs=model.layers[-2].output)\ntsne_model.compile(tf.keras.optimizers.Adam(lr=1e-4),loss='categorical_crossentropy',metrics=['accuracy'])\ntsne_model.summary()\n\n### ArcFace Model\n#with tpu_strategy.scope():        \ntsne_model = tf.keras.models.Model(inputs=model.input,outputs=model.layers[-3].output)\ntsne_model.compile(tf.keras.optimizers.Adam(lr=1e-4),loss='categorical_crossentropy',metrics=['accuracy'])\ntsne_model.summary()\n\n##### Predicting\n#mat_1 = tsne_model.predict(X_dev)\nmat_1 = tsne_model.predict([X_dev,y_dev_ohot])      \n\n###### Testing and Refining Embeddings\nimport math\nfor i in range(2):\n    print(mat_1[i])\n    \nfor i in range(mat_1.shape[0]):\n    for j in range(mat_1.shape[1]):\n        if(math.isnan(mat_1[i,j])):\n            mat_1[i,j] == 0\n        if(mat_1[i,j]>1e4):\n            mat_1[i,j] == 1e4","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"###### Verification Style Data Arrangment\n! mkdir './5B_Verification'\n! mkdir './5B_Verification/Probe'\n! mkdir './5B_Verification/Gallery'\n\nEnrolment_Ratio = 0.5 # This Signifies the ratio of Enrolment vs Evaluation\n\nfor i in range(48): # Looping over all the Dev Set Examples\n\n    ##### Creation of SubFolders\n    current_folder_gallery = './5B_Verification/Gallery/Person'+str(i)\n    current_folder_probe = './5B_Verification/Probe/Person'+str(i)\n\n    Path(current_folder_gallery).mkdir(parents=True, exist_ok=True)\n    Path(current_folder_probe).mkdir(parents=True, exist_ok=True)\n\n    ##### Curating List of Examples belonging to Class 'i'\n    item_index = []\n    for j in range(X_dev.shape[0]):\n        if(y_dev[j] == i):\n            item_index.append(j)\n            \n    ##### Probe and Gallery Divison\n    #divison_range = int(len(item_index)*Enrolment_Ratio)\n\n    #### Gallery Appendment\n    #for a in range(divison_range):\n    #    path_curr = current_folder_gallery+'/'+str(a)\n    #    np.savez_compressed(path_curr,mat_1[int(item_index[a])])\n\n    #### Probe Appendment\n    #for b in range(divison_range,len(item_index)):\n    #    path_curr = current_folder_probe+'/'+str(b-divison_range)\n    #    np.savez_compressed(path_curr,mat_1[int(item_index[b])])\n\n    print('Data Arranged for Person '+str(i)) # Declaration of Data Arrangment for the 'i'th Person","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"Matching_Matrix = [] # For Appending the Scores onto a List\nmatch_text = open(\"./5B_Matching_50_50_Final.txt\",'w') # Matching Text File Creation\n\nprobe_path = './5B_Verification/Probe'\ngallery_path = './5B_Verification/Gallery'\n\nfor probe_person_id,probe_person in enumerate(list(np.sort(os.listdir(probe_path)))): #Loop over the Probe Folder\n    probe_person_path = os.path.join(probe_path,probe_person)\n\n    print('Processing For User Probe '+str(probe_person_id))\n\n    for probe_id,probe_file in enumerate(list(np.sort(os.listdir(probe_person_path)))): #Loop over the Probe Person\n        probe_file_path = os.path.join(probe_person_path,probe_file)\n        probe = np.load(probe_file_path,allow_pickle='True')['arr_0'] # Current Probe\n\n        for gallery_person_id,gallery_person in enumerate(list(np.sort(os.listdir(gallery_path)))): #Loop over the Galleryy Folder\n            gallery_person_path = os.path.join(gallery_path,gallery_person)\n            \n            #print('Processing For User Gallery '+str(gallery_person_id)+' and User Probe '+str(probe_person_id))\n\n            for gallery_id,gallery_file in enumerate(list(np.sort(os.listdir(gallery_person_path)))):\n                gallery_file_path = os.path.join(gallery_person_path,gallery_file)\n                gallery = np.load(gallery_file_path,allow_pickle='True')['arr_0'] # Current Gallery\n\n                if(probe_person_id <= 17 and gallery_person_id <=17): # Doing Analysis over 18 subjects\n                \n                    ##### Metrics Computation\n                    #if(subject_probe_id != subject_gallery_id and probe_id != gallery_id):\n                    distance = (np.linalg.norm(probe-gallery)) #Euclidean Distance between Probe and Gallery\n                    #print(distance)\n                    if(probe_person_id == gallery_person_id):\n                        identity_flag = 1\n                    else:\n                        identity_flag = 0\n                    current_matching_matrix = [probe_person_id+1,probe_id+1,gallery_person_id+1,gallery_id+1,identity_flag,distance]\n\n                    ### For Array Appending       \n                    #Matching_Matrix.append(current_mathing_matrix)   \n\n                    ### For Text File Appending\n                    for item_idx,item in enumerate(current_matching_matrix):   \n                        if(item_idx <= 4):                  \n                            match_text.write(str(item)+'            ')                  \n                        else:                                    \n                            match_text.write(str(item)+\"\\n\")   \n                else:\n                    break ","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"###### Matching File Generation\nMatching_Matrix = [] # For Appending the Scores onto a List\nmatch_text = open(\"./OSV_50-50_Test-2.txt\",'w') # Matching Text File Creation   \nnum_probe_samples = 24 # Number of Subjects to be considered in Probe            \nnum_gallery_samples = 24 # Number of Subjects to be considered in Gallery                     \n\n##### Probe Selection\nfor probe_class in range(num_probe_samples): # Looping over Probe Examples\n    \n    print('Currently Processing for Probe Class '+str(probe_class))\n\n    #### Curating List of Examples belonging to Class 'probe_class'\n    item_index = []\n    for j in range(X_dev.shape[0]):\n        if(y_dev[j] == probe_class):\n            item_index.append(j)   \n\n    for probe_id,probe_loc in enumerate(item_index):\n        probe = Test_Embeddings[probe_loc] # Probe Selection \n\n        ##### Gallery Selection\n        for gallery_class in range(num_gallery_samples): # Looping over Gallery Examples\n\n            #print('Currently Processing for Gallery Class '+str(gallery_class))\n\n            #### Curating List of Examples belonging to Class 'probe_class'\n            item_index = []\n            for j in range(X_train.shape[0]):\n                if(y_train[j] == gallery_class):\n                    item_index.append(j)   \n\n            for gallery_id,gallery_loc in enumerate(item_index):\n                gallery = Train_Embeddings[gallery_loc] # Probe Selection \n\n                #### Metrics Computation \n                cos_distance = distance.cosine(probe,gallery) # Cosine Distance between Probe and Gallery\n                \n                if(probe_class == gallery_class): # Identity Flag\n                    identity_flag = 1\n                else:\n                    identity_flag = 0\n                current_matching_matrix = [probe_class+1,probe_id+1,gallery_class+1,gallery_id+1,identity_flag,cos_distance]\n                \n                ### For Array Appending       \n                #Matching_Matrix.append(current_mathing_matrix)\n\n                ### For Text File Appending\n                for item_idx,item in enumerate(current_matching_matrix):\n                    if(item_idx <= 4):\n                        match_text.write(str(item)+'            ')\n                    else:            \n                        match_text.write(str(item)+\"\\n\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]}]}